diff options
Diffstat (limited to 'src/main/java/gregtech/api/items')
15 files changed, 3850 insertions, 0 deletions
diff --git a/src/main/java/gregtech/api/items/GT_Block_LongDistancePipe.java b/src/main/java/gregtech/api/items/GT_Block_LongDistancePipe.java new file mode 100644 index 0000000000..31a44f3dbc --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_Block_LongDistancePipe.java @@ -0,0 +1,125 @@ +package gregtech.api.items; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EnumCreatureType; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.util.StatCollector; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTech_API; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.util.GT_LanguageManager; +import gregtech.common.blocks.GT_Item_LongDistancePipe; +import gregtech.common.blocks.GT_Material_Machines; + +public class GT_Block_LongDistancePipe extends GT_Generic_Block { + + public IIconContainer[] mIcons; + + public GT_Block_LongDistancePipe() { + super(GT_Item_LongDistancePipe.class, "gt.block.longdistancepipe", new GT_Material_Machines()); + setStepSound(soundTypeMetal); + setCreativeTab(GregTech_API.TAB_GREGTECH); + GregTech_API.registerMachineBlock(this, -1); + + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".0.name", "Long Distance Fluid Pipeline Pipe"); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".1.name", "Long Distance Item Pipeline Pipe"); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + "." + 32767 + ".name", "Any Sub Block of this"); + + ItemList.Long_Distance_Pipeline_Fluid_Pipe.set(new ItemStack(this, 1, 0)); + ItemList.Long_Distance_Pipeline_Item_Pipe.set(new ItemStack(this, 1, 1)); + mIcons = new IIconContainer[] { Textures.BlockIcons.LONG_DISTANCE_PIPE_FLUID, + Textures.BlockIcons.LONG_DISTANCE_PIPE_ITEM }; + } + + @Override + public void onBlockAdded(World aWorld, int aX, int aY, int aZ) { + super.onBlockAdded(aWorld, aX, aY, aZ); + if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) { + GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); + } + } + + @Override + public void breakBlock(World aWorld, int aX, int aY, int aZ, Block aBlock, int aMetaData) { + GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); + super.breakBlock(aWorld, aX, aY, aZ, aBlock, aMetaData); + } + + @Override + public String getHarvestTool(int aMeta) { + return "wrench"; + } + + @Override + public int getHarvestLevel(int aMeta) { + return 2; + } + + @Override + public float getBlockHardness(World aWorld, int aX, int aY, int aZ) { + return Blocks.stone.getBlockHardness(aWorld, aX, aY, aZ); + } + + @Override + public float getExplosionResistance(Entity aTNT) { + return Blocks.iron_block.getExplosionResistance(aTNT); + } + + @Override + public String getUnlocalizedName() { + return this.mUnlocalizedName; + } + + @Override + public String getLocalizedName() { + return StatCollector.translateToLocal(this.mUnlocalizedName + ".name"); + } + + @Override + public IIcon getIcon(int ordinalSide, int aMeta) { + return mIcons[aMeta % mIcons.length].getIcon(); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister aIconRegister) {} + + @Override + public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) { + return false; + } + + @Override + public int damageDropped(int metadata) { + return metadata; + } + + @Override + public int getDamageValue(World aWorld, int aX, int aY, int aZ) { + return aWorld.getBlockMetadata(aX, aY, aZ); + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubBlocks(Item aItem, CreativeTabs aCreativeTab, List<ItemStack> aList) { + for (int i = 0; i < 3; i++) { + ItemStack aStack = new ItemStack(aItem, 1, i); + if (!aStack.getDisplayName() + .contains(".name")) aList.add(aStack); + } + } +} diff --git a/src/main/java/gregtech/api/items/GT_BreederCell_Item.java b/src/main/java/gregtech/api/items/GT_BreederCell_Item.java new file mode 100644 index 0000000000..438b0f467e --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_BreederCell_Item.java @@ -0,0 +1,153 @@ +package gregtech.api.items; + +import static gregtech.api.util.GT_Utility.formatNumbers; + +import java.util.List; +import java.util.function.Supplier; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.world.World; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.util.GT_Utility; +import ic2.api.reactor.IReactor; +import ic2.api.reactor.IReactorComponent; +import ic2.core.IC2Potion; + +/** + * A {@link ic2.core.item.reactor.ItemReactorLithiumCell}, but can be used to produce anything! + * + * @author glee8e + */ +public class GT_BreederCell_Item extends GT_Generic_Item implements IReactorComponent { + + protected final int mHeatBonusStep; + protected final int mHeatBonusMultiplier; + protected ItemStack mProduct; + protected boolean deflector = false; + protected boolean hidden = false; + protected boolean neiAdded = false; + + public GT_BreederCell_Item(String aUnlocalized, String aEnglish, String aEnglishTooltip, int aHeatBonusStep, + int aHeatBonusMultiplier, int aRequiredPulse, Supplier<ItemStack> aProduct) { + super(aUnlocalized, aEnglish, aEnglishTooltip); + this.mHeatBonusStep = aHeatBonusStep; + this.mHeatBonusMultiplier = aHeatBonusMultiplier; + this.setMaxDamage(aRequiredPulse); + setNoRepair(); + GregTech_API.sAfterGTPostload.add(() -> { + mProduct = aProduct.get(); + if (!hidden && !neiAdded) { + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(this)) + .itemOutputs(mProduct) + .setNEIDesc( + deflector ? "Neutron reflecting Breeder" : "Heat neutral Breeder", + String.format("Every %d reactor hull heat", mHeatBonusStep), + String.format("increase speed by %d00%%", mHeatBonusMultiplier), + String.format("Required pulses: %d", getMaxDamage())) + .duration(0) + .eut(0) + .addTo(RecipeMaps.ic2NuclearFakeRecipes); + + neiAdded = true; + } + }); + } + + public GT_BreederCell_Item setDeflector() { + deflector = true; + return this; + } + + public GT_BreederCell_Item setHidden() { + hidden = true; + return this; + } + + @Override + public void onUpdate(ItemStack stack, World world, Entity entity, int slotIndex, boolean isCurrentItem) { + if ((entity instanceof EntityLivingBase entityLiving)) { + if (!GT_Utility.isWearingFullRadioHazmat(entityLiving)) { + IC2Potion.radiation.applyTo(entityLiving, 20, 1); + } + } + } + + @Override + public void addAdditionalToolTips(List<String> aList, ItemStack aStack, EntityPlayer aPlayer) { + aList.add(transItem("019", "Bath with neutron in a hot reactor")); + int rDmg = aStack.getItemDamage() * 4 / getMaxDamage(); + EnumChatFormatting color2 = switch (rDmg) { + case 0 -> EnumChatFormatting.DARK_GRAY; + case 1, 2 -> EnumChatFormatting.GRAY; + default -> EnumChatFormatting.WHITE; + }; + aList.add( + String.format( + transItem("020", "Progress: %s/%s"), + "" + color2 + formatNumbers(aStack.getItemDamage()) + EnumChatFormatting.RESET, + "" + formatNumbers(getMaxDamage()))); + if (aStack.getItemDamage() > 0) aList.add(EnumChatFormatting.RED + transItem("021", "Radiation Hazard")); + } + + @Override + public int getItemStackLimit(ItemStack stack) { + return stack.getItemDamage() == 0 ? maxStackSize : 1; + } + + @Override + public void processChamber(IReactor reactor, ItemStack yourStack, int x, int y, boolean heatrun) {} + + @Override + public boolean acceptUraniumPulse(IReactor reactor, ItemStack yourStack, ItemStack pulsingStack, int youX, int youY, + int pulseX, int pulseY, boolean heatrun) { + if (heatrun) { + int myLevel = getNewDamage(reactor, yourStack); + if (myLevel >= getMaxDamage()) reactor.setItemAt(youX, youY, mProduct.copy()); + else yourStack.setItemDamage(myLevel); + } + + return deflector; + } + + protected int getNewDamage(IReactor reactor, ItemStack stack) { + return stack.getItemDamage() + 1 + reactor.getHeat() / mHeatBonusStep * mHeatBonusMultiplier; + } + + @Override + public boolean canStoreHeat(IReactor reactor, ItemStack yourStack, int x, int y) { + return false; + } + + @Override + public int getMaxHeat(IReactor reactor, ItemStack yourStack, int x, int y) { + return 0; + } + + @Override + public int getCurrentHeat(IReactor reactor, ItemStack yourStack, int x, int y) { + return 0; + } + + @Override + public int alterHeat(IReactor reactor, ItemStack yourStack, int x, int y, int heat) { + return heat; + } + + @Override + public float influenceExplosion(IReactor reactor, ItemStack yourStack) { + return 0.0F; + } + + @Override + public double getDurabilityForDisplay(ItemStack stack) { + return 1.0D - (double) stack.getItemDamageForDisplay() / (double) stack.getMaxDamage(); + } +} diff --git a/src/main/java/gregtech/api/items/GT_CoolantCellIC_Item.java b/src/main/java/gregtech/api/items/GT_CoolantCellIC_Item.java new file mode 100644 index 0000000000..eb3c6276cf --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_CoolantCellIC_Item.java @@ -0,0 +1,67 @@ +package gregtech.api.items; + +import net.minecraft.item.ItemStack; + +import ic2.api.reactor.IReactor; +import ic2.api.reactor.IReactorComponent; + +public class GT_CoolantCellIC_Item extends GT_CoolantCell_Item implements IReactorComponent { + + public GT_CoolantCellIC_Item(String aUnlocalized, String aEnglish, int aMaxStore) { + super(aUnlocalized, aEnglish, aMaxStore); + } + + @Override + public void processChamber(IReactor aReactor, ItemStack aStack, int x, int y, boolean aHeatRun) {} + + @Override + public boolean acceptUraniumPulse(IReactor aReactor, ItemStack aStack, ItemStack pulsingStack, int youX, int youY, + int pulseX, int pulseY, boolean aHeatRun) { + return false; + } + + @Override + public boolean canStoreHeat(IReactor aReactor, ItemStack aStack, int x, int y) { + return !aReactor.isFluidCooled() || getControlTagOfStack(aStack) == 0; + } + + @Override + public int getMaxHeat(IReactor aReactor, ItemStack aStack, int x, int y) { + return this.heatStorage; + } + + @Override + public int getCurrentHeat(IReactor aReactor, ItemStack aStack, int x, int y) { + return getHeatOfStack(aStack); + } + + @Override + public float influenceExplosion(IReactor aReactor, ItemStack aStack) { + return 1.0F + this.heatStorage / 30000.0F; + } + + @Override + public int alterHeat(IReactor aReactor, ItemStack aStack, int x, int y, int aHeat) { + int tHeat = getHeatOfStack(aStack); + if ((tHeat == 0) && (getControlTagOfStack(aStack) != 0)) { + setControlTagOfStack(aStack, 0); + } + tHeat += aHeat; + if (tHeat > this.heatStorage) { + aReactor.setItemAt(x, y, null); + aHeat = this.heatStorage - tHeat + 1; + } else { + if (tHeat < 0) { + aHeat = tHeat; + tHeat = 0; + } else { + aHeat = 0; + } + if ((tHeat > 0) && (getControlTagOfStack(aStack) == 0) && (!aReactor.isFluidCooled())) { + setControlTagOfStack(aStack, 1); + } + setHeatForStack(aStack, tHeat); + } + return aHeat; + } +} diff --git a/src/main/java/gregtech/api/items/GT_CoolantCell_Item.java b/src/main/java/gregtech/api/items/GT_CoolantCell_Item.java new file mode 100644 index 0000000000..6ed7dae3b0 --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_CoolantCell_Item.java @@ -0,0 +1,82 @@ +package gregtech.api.items; + +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; + +import gregtech.api.GregTech_API; +import ic2.core.util.StackUtil; + +public class GT_CoolantCell_Item extends GT_Generic_Item { + + protected final int heatStorage; + + public GT_CoolantCell_Item(String aUnlocalized, String aEnglish, int aMaxStore) { + super(aUnlocalized, aEnglish, null); + this.setMaxStackSize(1); + this.setMaxDamage(100); + setNoRepair(); + this.heatStorage = aMaxStore; + this.setCreativeTab(GregTech_API.TAB_GREGTECH); + } + + protected static int getHeatOfStack(ItemStack aStack) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + tNBT = new NBTTagCompound(); + aStack.setTagCompound(tNBT); + } + return tNBT.getInteger("heat"); + } + + protected void setHeatForStack(ItemStack aStack, int aHeat) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + tNBT = new NBTTagCompound(); + aStack.setTagCompound(tNBT); + } + tNBT.setInteger("heat", aHeat); + if (this.heatStorage > 0) { + double heatRatio = (double) aHeat / (double) this.heatStorage; + int damage = (int) (aStack.getMaxDamage() * heatRatio); + if (damage >= aStack.getMaxDamage()) { + damage = aStack.getMaxDamage() - 1; + } + aStack.setItemDamage(damage); + } + } + + @Override + public void addAdditionalToolTips(List<String> aList, ItemStack aStack, EntityPlayer aPlayer) { + super.addAdditionalToolTips(aList, aStack, aPlayer); + int rHeat = getHeatOfStack(aStack) * 10 / this.heatStorage; + EnumChatFormatting color = switch (rHeat) { + case 0 -> EnumChatFormatting.BLUE; + case 1, 2 -> EnumChatFormatting.GREEN; + case 3, 4, 5, 6 -> EnumChatFormatting.YELLOW; + case 7, 8 -> EnumChatFormatting.RED; + default -> EnumChatFormatting.DARK_RED; + }; + aList.add( + EnumChatFormatting.WHITE + + String.format(transItem("000", "Stored Heat: %s"), "" + color + getHeatOfStack(aStack))); + if (getControlTagOfStack(aStack) == 1) { + aList.add(StatCollector.translateToLocal("ic2.reactoritem.heatwarning.line1")); + aList.add(StatCollector.translateToLocal("ic2.reactoritem.heatwarning.line2")); + } + } + + public int getControlTagOfStack(ItemStack stack) { + NBTTagCompound nbtData = StackUtil.getOrCreateNbtData(stack); + return nbtData.getInteger("tag"); + } + + public void setControlTagOfStack(ItemStack stack, int tag) { + NBTTagCompound nbtData = StackUtil.getOrCreateNbtData(stack); + nbtData.setInteger("tag", tag); + } +} diff --git a/src/main/java/gregtech/api/items/GT_EnergyArmor_Item.java b/src/main/java/gregtech/api/items/GT_EnergyArmor_Item.java new file mode 100644 index 0000000000..df820f928a --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_EnergyArmor_Item.java @@ -0,0 +1,332 @@ +package gregtech.api.items; + +import static gregtech.api.enums.Mods.GregTech; + +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemArmor; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.potion.Potion; +import net.minecraft.potion.PotionEffect; +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.event.entity.living.LivingFallEvent; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTech_API; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Utility; + +public class GT_EnergyArmor_Item extends ItemArmor implements ISpecialArmor { + + public static Map<EntityPlayer, Float> jumpChargeMap = new ConcurrentHashMap<>(); + public int mCharge, mTransfer, mTier, mDamageEnergyCost, mSpecials; + public boolean mChargeProvider; + public double mArmorAbsorbtionPercentage; + + public GT_EnergyArmor_Item(int aID, String aUnlocalized, String aEnglish, int aCharge, int aTransfer, int aTier, + int aDamageEnergyCost, int aSpecials, double aArmorAbsorbtionPercentage, boolean aChargeProvider, int aType, + int aArmorIndex) { + super(ArmorMaterial.DIAMOND, aArmorIndex, aType); + setMaxStackSize(1); + setMaxDamage(100); + setNoRepair(); + setUnlocalizedName(aUnlocalized); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".name", aEnglish); + mCharge = Math.max(1, aCharge); + mTransfer = Math.max(1, aTransfer); + mTier = Math.max(1, aTier); + mSpecials = aSpecials; + mChargeProvider = aChargeProvider; + mDamageEnergyCost = Math.max(0, aDamageEnergyCost); + mArmorAbsorbtionPercentage = aArmorAbsorbtionPercentage; + + setCreativeTab(GregTech_API.TAB_GREGTECH); + + MinecraftForge.EVENT_BUS.register(this); + } + + private static void setCharge(ItemStack aStack) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) tNBT = new NBTTagCompound(); + tNBT.setInteger("charge", 1000000000); + aStack.setTagCompound(tNBT); + } + + @Override + public ItemStack onItemRightClick(ItemStack aStack, World aWorld, EntityPlayer aPlayer) { + ItemStack tStack = aPlayer.inventory.armorInventory[3 - armorType]; + if (tStack != null) { + for (int i = 0; i < 9; i++) { + if (aPlayer.inventory.mainInventory[i] == aStack) { + aPlayer.inventory.armorInventory[3 - armorType] = aPlayer.inventory.mainInventory[i]; + aPlayer.inventory.mainInventory[i] = tStack; + return tStack; + } + } + } + return super.onItemRightClick(aStack, aWorld, aPlayer); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aIconRegister) { + this.itemIcon = aIconRegister.registerIcon(GregTech.getResourcePath(getUnlocalizedName())); + } + + @Override + public void addInformation(ItemStack aStack, EntityPlayer aPlayer, List<String> aList, boolean aF3_H) { + aList.add("Tier: " + mTier); + if ((mSpecials & 1) != 0) aList.add("Rebreather"); + if ((mSpecials & 2) != 0) aList.add("Inertia Damper"); + if ((mSpecials & 4) != 0) aList.add("Food Replicator"); + if ((mSpecials & 8) != 0) aList.add("Medicine Module"); + if ((mSpecials & 16) != 0) aList.add("Lamp"); + if ((mSpecials & 32) != 0) aList.add("Solarpanel"); + if ((mSpecials & 64) != 0) aList.add("Extinguisher Module"); + if ((mSpecials & 128) != 0) aList.add("Jump Booster"); + if ((mSpecials & 256) != 0) aList.add("Speed Booster"); + if ((mSpecials & 512) != 0) aList.add("Invisibility Field"); + if ((mSpecials & 1024) != 0) aList.add("Infinite Charge"); + } + + @Override + public void onArmorTick(World aWorld, EntityPlayer aPlayer, ItemStack aStack) { + if (mSpecials == 0) return; + + if (!aPlayer.worldObj.isRemote && (mSpecials & 1) != 0) { + int airSupply = aPlayer.getAir(); + if (GT_ModHandler.canUseElectricItem(aStack, 1000) && airSupply < 50) { + aPlayer.setAir(airSupply + 250); + GT_ModHandler.useElectricItem(aStack, 1000, aPlayer); + } + } + + if (!aPlayer.worldObj.isRemote && (mSpecials & 4) != 0) { + if (GT_ModHandler.canUseElectricItem(aStack, 50000) && aPlayer.getFoodStats() + .needFood()) { + aPlayer.getFoodStats() + .addStats(1, 0.0F); + GT_ModHandler.useElectricItem(aStack, 50000, aPlayer); + } + } + + if ((mSpecials & 8) != 0) { + if (GT_ModHandler.canUseElectricItem(aStack, 10000) && aPlayer.isPotionActive(Potion.poison)) { + GT_Utility.removePotion(aPlayer, Potion.poison.id); + GT_ModHandler.useElectricItem(aStack, 10000, aPlayer); + } + if (GT_ModHandler.canUseElectricItem(aStack, 100000) && aPlayer.isPotionActive(Potion.wither)) { + GT_Utility.removePotion(aPlayer, Potion.wither.id); + GT_ModHandler.useElectricItem(aStack, 100000, aPlayer); + } + } + + if ((mSpecials & 64) != 0) { + aPlayer.setFire(0); + } + + if (!aPlayer.worldObj.isRemote && (mSpecials & 128) != 0) { + float jumpCharge = jumpChargeMap.getOrDefault(aPlayer, 1.0F); + + if (GT_ModHandler.canUseElectricItem(aStack, 1000) && aPlayer.onGround && jumpCharge < 1.0F) { + jumpCharge = 1.0F; + GT_ModHandler.useElectricItem(aStack, 1000, aPlayer); + } + + if (aPlayer.motionY >= 0.0D && jumpCharge > 0.0F && !aPlayer.isInWater()) { + if (jumpCharge < 1.0F) { + jumpCharge = 0.0F; + } + } + + jumpChargeMap.put(aPlayer, jumpCharge); + } + + if ((mSpecials & 256) != 0) { + if (GT_ModHandler.canUseElectricItem(aStack, 100) && aPlayer.isSprinting() + && (aPlayer.onGround && Math.abs(aPlayer.motionX) + Math.abs(aPlayer.motionZ) > 0.10000000149011612D + || aPlayer.isInWater())) { + GT_ModHandler.useElectricItem(aStack, 100, aPlayer); + float bonus = 0.22F; + + if (aPlayer.isInWater()) { + GT_ModHandler.useElectricItem(aStack, 100, aPlayer); + bonus = 0.1F; + + if (aPlayer.motionY > 0) { + aPlayer.motionY += 0.10000000149011612D; + } + } + + aPlayer.moveFlying(0.0F, 1.0F, bonus); + } + } + + if ((mSpecials & 512) != 0) { + if (GT_ModHandler.canUseElectricItem(aStack, 10000)) { + GT_ModHandler.useElectricItem(aStack, 10000, aPlayer); + aPlayer.addPotionEffect(new PotionEffect(Potion.invisibility.getId(), 25, 1, true)); + } + } + + if (!aPlayer.worldObj.isRemote && (mSpecials & (16 | 32)) != 0) { + // if (GregTech_API.sWorldTickCounter%20==0) { + ItemStack tTargetChargeItem = aStack, tTargetDechargeItem = aStack; + + if (GT_ModHandler.chargeElectricItem(tTargetChargeItem, 1, Integer.MAX_VALUE, true, true) < 1) { + tTargetChargeItem = aPlayer.inventory.armorInventory[2]; + } + if (GT_ModHandler.dischargeElectricItem(tTargetDechargeItem, 10, Integer.MAX_VALUE, true, true, true) + < 10) { + tTargetDechargeItem = aPlayer.inventory.armorInventory[2]; + } + + if (tTargetChargeItem == null || !GT_ModHandler.isElectricItem(tTargetChargeItem)) { + tTargetChargeItem = null; + } + + if (aPlayer.worldObj.isDaytime() && aPlayer.worldObj.canBlockSeeTheSky( + MathHelper.floor_double(aPlayer.posX), + MathHelper.floor_double(aPlayer.posY + 1), + MathHelper.floor_double(aPlayer.posZ))) { + if ((mSpecials & 32) != 0 && tTargetChargeItem != null) { + GT_ModHandler.chargeElectricItem(tTargetChargeItem, 20, Integer.MAX_VALUE, true, false); + } + } else { + /* + * TODO: if ((mSpecials & 16) != 0 && tTargetDechargeItem != null && + * GT_ModHandler.canUseElectricItem(tTargetDechargeItem, 10)) { if (aPlayer.worldObj.getBlock + * ((int)aPlayer.posX, (int)aPlayer.posY+1, (int)aPlayer.posZ) == Blocks.air) aPlayer.worldObj.setBlock + * ((int)aPlayer.posX, (int)aPlayer.posY+1, (int)aPlayer.posZ, GregTech_API.sBlockList[3]); + * GT_ModHandler.useElectricItem(tTargetDechargeItem, 10, aPlayer); } + */ + // } + } + } + } + + @Override + public boolean getShareTag() { + return true; + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item aItem, CreativeTabs creativeTab, List<ItemStack> outputSubItems) { + ItemStack tCharged = new ItemStack(this, 1), tUncharged = new ItemStack(this, 1, getMaxDamage()); + GT_ModHandler.chargeElectricItem(tCharged, Integer.MAX_VALUE, Integer.MAX_VALUE, true, false); + outputSubItems.add(tCharged); + outputSubItems.add(tUncharged); + } + + public boolean canProvideEnergy(ItemStack aStack) { + if ((mSpecials & 1024) != 0) setCharge(aStack); + return mChargeProvider; + } + + public Item getChargedItem(ItemStack aStack) { + if ((mSpecials & 1024) != 0) setCharge(aStack); + return this; + } + + public Item getEmptyItem(ItemStack aStack) { + if ((mSpecials & 1024) != 0) setCharge(aStack); + return this; + } + + public int getMaxCharge(ItemStack aStack) { + if ((mSpecials & 1024) != 0) setCharge(aStack); + return mCharge; + } + + public int getTier(ItemStack aStack) { + if ((mSpecials & 1024) != 0) setCharge(aStack); + return mTier; + } + + public int getTransferLimit(ItemStack aStack) { + if ((mSpecials & 1024) != 0) setCharge(aStack); + return mTransfer; + } + + @Override + public int getItemEnchantability() { + return 0; + } + + @Override + public boolean isBookEnchantable(ItemStack ingredient, ItemStack bookEnchant) { + return false; + } + + @Override + public boolean getIsRepairable(ItemStack toBeRepaired, ItemStack repairWith) { + return false; + } + + // TODO: @ForgeSubscribe + public void onEntityLivingFallEvent(LivingFallEvent event) { + if (!event.entity.worldObj.isRemote && event.entity instanceof EntityPlayer player) { + for (int i = 0; i < 4; i++) { + ItemStack armor = player.inventory.armorInventory[i]; + if (armor != null && armor.getItem() == this && (mSpecials & 2) != 0) { + int distanceFactor = (int) event.distance - 3; + int energyCost = (this.mDamageEnergyCost * distanceFactor) / 4; + if (energyCost <= GT_ModHandler + .dischargeElectricItem(armor, Integer.MAX_VALUE, Integer.MAX_VALUE, true, true, true)) { + GT_ModHandler.dischargeElectricItem(armor, energyCost, Integer.MAX_VALUE, true, false, true); + event.setCanceled(true); + break; + } + } + } + } + } + + @Override + public ISpecialArmor.ArmorProperties getProperties(EntityLivingBase player, ItemStack armor, DamageSource source, + double damage, int slotIndex) { + return new ISpecialArmor.ArmorProperties( + (source == DamageSource.fall && (mSpecials & 2) != 0) ? 10 : 0, + getBaseAbsorptionRatio() * mArmorAbsorbtionPercentage, + mDamageEnergyCost > 0 ? 25 + * GT_ModHandler.dischargeElectricItem(armor, Integer.MAX_VALUE, Integer.MAX_VALUE, true, true, true) + / mDamageEnergyCost : 0); + } + + @Override + public int getArmorDisplay(EntityPlayer player, ItemStack armor, int slotIndex) { + return (int) Math.round(20.0D * getBaseAbsorptionRatio() * mArmorAbsorbtionPercentage); + } + + @Override + public void damageArmor(EntityLivingBase entity, ItemStack itemStack, DamageSource source, int damage, + int slotIndex) { + GT_ModHandler + .dischargeElectricItem(itemStack, damage * mDamageEnergyCost, Integer.MAX_VALUE, true, false, true); + } + + private double getBaseAbsorptionRatio() { + if (mArmorAbsorbtionPercentage <= 0) return 0.00; + return switch (this.armorType) { + case 0, 3 -> 0.15; + case 1 -> 0.40; + case 2 -> 0.30; + default -> 0.00; + }; + } +} diff --git a/src/main/java/gregtech/api/items/GT_Generic_Block.java b/src/main/java/gregtech/api/items/GT_Generic_Block.java new file mode 100644 index 0000000000..7aaef6d5ca --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_Generic_Block.java @@ -0,0 +1,22 @@ +package gregtech.api.items; + +import static gregtech.api.enums.GT_Values.W; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.item.ItemBlock; + +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.util.GT_LanguageManager; + +public class GT_Generic_Block extends Block { + + protected final String mUnlocalizedName; + + protected GT_Generic_Block(Class<? extends ItemBlock> aItemClass, String aName, Material aMaterial) { + super(aMaterial); + setBlockName(mUnlocalizedName = aName); + GameRegistry.registerBlock(this, aItemClass, getUnlocalizedName()); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + "." + W + ".name", "Any Sub Block of this one"); + } +} diff --git a/src/main/java/gregtech/api/items/GT_Generic_Item.java b/src/main/java/gregtech/api/items/GT_Generic_Item.java new file mode 100644 index 0000000000..3fe2083a96 --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_Generic_Item.java @@ -0,0 +1,162 @@ +package gregtech.api.items; + +import static gregtech.api.enums.Mods.GregTech; + +import java.util.List; + +import net.minecraft.block.BlockDispenser; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.dispenser.BehaviorDefaultDispenseItem; +import net.minecraft.dispenser.BehaviorProjectileDispense; +import net.minecraft.dispenser.IBlockSource; +import net.minecraft.dispenser.IPosition; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.IProjectile; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.projectile.EntityArrow; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTech_API; +import gregtech.api.enums.SubTag; +import gregtech.api.interfaces.IProjectileItem; +import gregtech.api.util.GT_Config; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Utility; + +/** + * Extended by most Items, also used as a fallback Item, to prevent the accidental deletion when Errors occur. + */ +public class GT_Generic_Item extends Item implements IProjectileItem { + + private final String mName, mTooltip; + protected IIcon mIcon; + + public GT_Generic_Item(String aUnlocalized, String aEnglish, String aEnglishTooltip) { + super(); + mName = "gt." + aUnlocalized; + GT_LanguageManager.addStringLocalization(mName + ".name", aEnglish); + if (GT_Utility.isStringValid(aEnglishTooltip)) + GT_LanguageManager.addStringLocalization(mTooltip = mName + ".tooltip_main", aEnglishTooltip); + else mTooltip = null; + setCreativeTab(GregTech_API.TAB_GREGTECH); + GameRegistry.registerItem(this, mName, GregTech.ID); + BlockDispenser.dispenseBehaviorRegistry.putObject(this, new GT_Item_Dispense()); + } + + @Override + public final Item setUnlocalizedName(String aName) { + return this; + } + + @Override + public final String getUnlocalizedName() { + return mName; + } + + @Override + public String getUnlocalizedName(ItemStack aStack) { + return getHasSubtypes() ? mName + "." + getDamage(aStack) : mName; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aIconRegister) { + mIcon = aIconRegister.registerIcon(GregTech.getResourcePath(GT_Config.troll ? "troll" : mName)); + } + + @Override + public boolean doesSneakBypassUse(World aWorld, int aX, int aY, int aZ, EntityPlayer aPlayer) { + return true; + } + + @Override + public IIcon getIconFromDamage(int aMetaData) { + return mIcon; + } + + public int getTier(ItemStack aStack) { + return 0; + } + + @Override + public void addInformation(ItemStack aStack, EntityPlayer aPlayer, List<String> aList, boolean aF3_H) { + if (getMaxDamage() > 0 && !getHasSubtypes()) + aList.add((aStack.getMaxDamage() - getDamage(aStack)) + " / " + aStack.getMaxDamage()); + if (mTooltip != null) aList.add(GT_LanguageManager.getTranslation(mTooltip)); + if (GT_ModHandler.isElectricItem(aStack)) aList.add("Tier: " + getTier(aStack)); + addAdditionalToolTips(aList, aStack, aPlayer); + } + + protected void addAdditionalToolTips(List<String> aList, ItemStack aStack, EntityPlayer aPlayer) { + // + } + + @Override + public void onCreated(ItemStack aStack, World aWorld, EntityPlayer aPlayer) { + isItemStackUsable(aStack); + } + + public boolean isItemStackUsable(ItemStack aStack) { + return true; + } + + public ItemStack onDispense(IBlockSource aSource, ItemStack aStack) { + EnumFacing enumfacing = BlockDispenser.func_149937_b(aSource.getBlockMetadata()); + IPosition iposition = BlockDispenser.func_149939_a(aSource); + ItemStack itemstack1 = aStack.splitStack(1); + BehaviorDefaultDispenseItem.doDispense(aSource.getWorld(), itemstack1, 6, enumfacing, iposition); + return aStack; + } + + @Override + public EntityArrow getProjectile(SubTag aProjectileType, ItemStack aStack, World aWorld, double aX, double aY, + double aZ) { + return null; + } + + @Override + public EntityArrow getProjectile(SubTag aProjectileType, ItemStack aStack, World aWorld, EntityLivingBase aEntity, + float aSpeed) { + return null; + } + + @Override + public boolean hasProjectile(SubTag aProjectileType, ItemStack aStack) { + return false; + } + + @Override + public ItemStack getContainerItem(ItemStack aStack) { + return null; + } + + @Override + public boolean hasContainerItem(ItemStack aStack) { + return getContainerItem(aStack) != null; + } + + public String transItem(String aKey, String aEnglish) { + return GT_LanguageManager.addStringLocalization("Item_DESCRIPTION_Index_" + aKey, aEnglish); + } + + public static class GT_Item_Dispense extends BehaviorProjectileDispense { + + @Override + public ItemStack dispenseStack(IBlockSource aSource, ItemStack aStack) { + return ((GT_Generic_Item) aStack.getItem()).onDispense(aSource, aStack); + } + + @Override + protected IProjectile getProjectileEntity(World aWorld, IPosition aPosition) { + return null; + } + } +} diff --git a/src/main/java/gregtech/api/items/GT_MetaBase_Item.java b/src/main/java/gregtech/api/items/GT_MetaBase_Item.java new file mode 100644 index 0000000000..481c0b5a08 --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_MetaBase_Item.java @@ -0,0 +1,622 @@ +package gregtech.api.items; + +import static gregtech.api.enums.GT_Values.D1; +import static gregtech.api.enums.GT_Values.V; +import static gregtech.api.util.GT_Utility.formatNumbers; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.ConcurrentHashMap; + +import net.minecraft.dispenser.IBlockSource; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.projectile.EntityArrow; +import net.minecraft.inventory.Container; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidContainerItem; + +import gregtech.api.enums.SubTag; +import gregtech.api.interfaces.IItemBehaviour; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Utility; +import ic2.api.item.ElectricItem; +import ic2.api.item.IElectricItem; +import ic2.api.item.IElectricItemManager; +import ic2.api.item.ISpecialElectricItem; + +public abstract class GT_MetaBase_Item extends GT_Generic_Item + implements ISpecialElectricItem, IElectricItemManager, IFluidContainerItem { + + /* ---------- CONSTRUCTOR AND MEMBER VARIABLES ---------- */ + private final ConcurrentHashMap<Short, ArrayList<IItemBehaviour<GT_MetaBase_Item>>> mItemBehaviors = new ConcurrentHashMap<>(); + + /** + * Creates the Item using these Parameters. + * + * @param aUnlocalized The Unlocalized Name of this Item. + */ + public GT_MetaBase_Item(String aUnlocalized) { + super(aUnlocalized, "Generated Item", null); + setHasSubtypes(true); + setMaxDamage(0); + } + + /** + * Adds a special Item Behaviour to the Item. + * <p/> + * Note: the boolean Behaviours sometimes won't be executed if another boolean Behaviour returned true before. + * + * @param aMetaValue the Meta Value of the Item you want to add it to. [0 - 32765] + * @param aBehavior the Click Behavior you want to add. + * @return the Item itself for convenience in constructing. + */ + public final GT_MetaBase_Item addItemBehavior(int aMetaValue, IItemBehaviour<GT_MetaBase_Item> aBehavior) { + if (aMetaValue < 0 || aMetaValue >= 32766 || aBehavior == null) return this; + ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors + .computeIfAbsent((short) aMetaValue, k -> new ArrayList<>(1)); + tList.add(aBehavior); + return this; + } + + public abstract Long[] getElectricStats(ItemStack aStack); + + public abstract Long[] getFluidContainerStats(ItemStack aStack); + + @Override + public boolean hasProjectile(SubTag aProjectileType, ItemStack aStack) { + ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short) getDamage(aStack)); + if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) + if (tBehavior.hasProjectile(this, aProjectileType, aStack)) return true; + return super.hasProjectile(aProjectileType, aStack); + } + + @Override + public EntityArrow getProjectile(SubTag aProjectileType, ItemStack aStack, World aWorld, double aX, double aY, + double aZ) { + ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short) getDamage(aStack)); + if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) { + EntityArrow rArrow = tBehavior.getProjectile(this, aProjectileType, aStack, aWorld, aX, aY, aZ); + if (rArrow != null) return rArrow; + } + return super.getProjectile(aProjectileType, aStack, aWorld, aX, aY, aZ); + } + + @Override + public EntityArrow getProjectile(SubTag aProjectileType, ItemStack aStack, World aWorld, EntityLivingBase aEntity, + float aSpeed) { + ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short) getDamage(aStack)); + if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) { + EntityArrow rArrow = tBehavior.getProjectile(this, aProjectileType, aStack, aWorld, aEntity, aSpeed); + if (rArrow != null) return rArrow; + } + return super.getProjectile(aProjectileType, aStack, aWorld, aEntity, aSpeed); + } + + @Override + public ItemStack onDispense(IBlockSource aSource, ItemStack aStack) { + ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short) getDamage(aStack)); + if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) + if (tBehavior.canDispense(this, aSource, aStack)) return tBehavior.onDispense(this, aSource, aStack); + return super.onDispense(aSource, aStack); + } + + @Override + public boolean isItemStackUsable(ItemStack aStack) { + ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short) getDamage(aStack)); + if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) + if (!tBehavior.isItemStackUsable(this, aStack)) return false; + return super.isItemStackUsable(aStack); + } + + @Override + public boolean onLeftClickEntity(ItemStack aStack, EntityPlayer aPlayer, Entity aEntity) { + use(aStack, 0, aPlayer); + isItemStackUsable(aStack); + ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short) getDamage(aStack)); + try { + if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) + if (tBehavior.onLeftClickEntity(this, aStack, aPlayer, aEntity)) { + if (aStack.stackSize <= 0) aPlayer.destroyCurrentEquippedItem(); + return true; + } + if (aStack.stackSize <= 0) { + aPlayer.destroyCurrentEquippedItem(); + return false; + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + return false; + } + + @Override + public boolean onItemUse(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, + int ordinalSide, float hitX, float hitY, float hitZ) { + use(aStack, 0, aPlayer); + isItemStackUsable(aStack); + ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short) getDamage(aStack)); + try { + if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) + if (tBehavior.onItemUse(this, aStack, aPlayer, aWorld, aX, aY, aZ, ordinalSide, hitX, hitY, hitZ)) { + if (aStack.stackSize <= 0) aPlayer.destroyCurrentEquippedItem(); + return true; + } + if (aStack.stackSize <= 0) { + aPlayer.destroyCurrentEquippedItem(); + return false; + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + return false; + } + + @Override + public boolean onItemUseFirst(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, + int ordinalSide, float hitX, float hitY, float hitZ) { + use(aStack, 0, aPlayer); + isItemStackUsable(aStack); + ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short) getDamage(aStack)); + try { + if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) if (tBehavior.onItemUseFirst( + this, + aStack, + aPlayer, + aWorld, + aX, + aY, + aZ, + ForgeDirection.getOrientation(ordinalSide), + hitX, + hitY, + hitZ)) { + if (aStack.stackSize <= 0) aPlayer.destroyCurrentEquippedItem(); + return true; + } + if (aStack.stackSize <= 0) { + aPlayer.destroyCurrentEquippedItem(); + return false; + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + return false; + } + + @Override + public ItemStack onItemRightClick(ItemStack aStack, World aWorld, EntityPlayer aPlayer) { + use(aStack, 0, aPlayer); + isItemStackUsable(aStack); + ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short) getDamage(aStack)); + try { + if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) + aStack = tBehavior.onItemRightClick(this, aStack, aWorld, aPlayer); + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + return aStack; + } + + @Override + public final void addInformation(ItemStack aStack, EntityPlayer aPlayer, List<String> aList, boolean aF3_H) { + String tKey = getUnlocalizedName(aStack) + ".tooltip"; + String[] tStrings = GT_LanguageManager.getTranslation(tKey) + .split("/n "); + for (String tString : tStrings) + if (GT_Utility.isStringValid(tString) && !tKey.equals(tString)) aList.add(tString); + + Long[] tStats = getElectricStats(aStack); + if (tStats != null) { + if (tStats[3] > 0) { + aList.add( + EnumChatFormatting.AQUA + String.format( + transItem("009", "Contains %s EU Tier: %s"), + formatNumbers(tStats[3]), + "" + (tStats[2] >= 0 ? tStats[2] : 0)) + EnumChatFormatting.GRAY); + } else { + long tCharge = getRealCharge(aStack); + if (tStats[3] == -2 && tCharge <= 0) { + aList.add( + EnumChatFormatting.AQUA + transItem("010", "Empty. You should recycle it properly.") + + EnumChatFormatting.GRAY); + } else { + aList.add( + EnumChatFormatting.AQUA + + String.format( + transItem("011", "%s / %s EU - Voltage: %s"), + formatNumbers(tCharge), + formatNumbers(Math.abs(tStats[0])), + "" + V[(int) (tStats[2] >= 0 ? tStats[2] < V.length ? tStats[2] : V.length - 1 : 1)]) + + EnumChatFormatting.GRAY); + } + } + } + + tStats = getFluidContainerStats(aStack); + if (tStats != null && tStats[0] > 0) { + FluidStack tFluid = getFluidContent(aStack); + aList.add( + EnumChatFormatting.BLUE + ((tFluid == null ? transItem("012", "No Fluids Contained") + : GT_Utility.getFluidName(tFluid, true))) + EnumChatFormatting.GRAY); + aList.add( + EnumChatFormatting.BLUE + String.format( + transItem("013", "%sL / %sL"), + "" + (tFluid == null ? 0 : formatNumbers(tFluid.amount)), + "" + formatNumbers(tStats[0])) + EnumChatFormatting.GRAY); + } + + ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short) getDamage(aStack)); + if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) + aList = tBehavior.getAdditionalToolTips(this, aList, aStack); + + addAdditionalToolTips(aList, aStack, aPlayer); + } + + @Override + public void onUpdate(ItemStack aStack, World aWorld, Entity aPlayer, int aTimer, boolean aIsInHand) { + ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short) getDamage(aStack)); + if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) + tBehavior.onUpdate(this, aStack, aWorld, aPlayer, aTimer, aIsInHand); + } + + @Override + public final boolean canProvideEnergy(ItemStack aStack) { + Long[] tStats = getElectricStats(aStack); + if (tStats == null) return false; + return tStats[3] > 0 || (aStack.stackSize == 1 && (tStats[3] == -2 || tStats[3] == -3)); + } + + @Override + public final double getMaxCharge(ItemStack aStack) { + Long[] tStats = getElectricStats(aStack); + if (tStats == null) return 0; + return Math.abs(tStats[0]); + } + + @Override + public final double getTransferLimit(ItemStack aStack) { + Long[] tStats = getElectricStats(aStack); + if (tStats == null) return 0; + return Math.max(tStats[1], tStats[3]); + } + + @Override + public final double charge(ItemStack aStack, double aCharge, int aTier, boolean aIgnoreTransferLimit, + boolean aSimulate) { + Long[] tStats = getElectricStats(aStack); + if (tStats == null || tStats[2] > aTier + || !(tStats[3] == -1 || tStats[3] == -3 || (tStats[3] < 0 && aCharge == Integer.MAX_VALUE)) + || aStack.stackSize != 1) return 0; + long tTransfer = aIgnoreTransferLimit ? (long) aCharge : Math.min(tStats[1], (long) aCharge); + long tChargeBefore = getRealCharge(aStack), tNewCharge = Math.min( + Math.abs(tStats[0]), + Long.MAX_VALUE - tTransfer >= tChargeBefore ? tChargeBefore + tTransfer : Long.MAX_VALUE); + if (!aSimulate) setCharge(aStack, tNewCharge); + return tNewCharge - tChargeBefore; + } + + @Override + public final double discharge(ItemStack aStack, double aCharge, int aTier, boolean aIgnoreTransferLimit, + boolean aBatteryAlike, boolean aSimulate) { + Long[] tStats = getElectricStats(aStack); + if (tStats == null || tStats[2] > aTier) return 0; + if (aBatteryAlike && !canProvideEnergy(aStack)) return 0; + if (tStats[3] > 0) { + if (aCharge < tStats[3] || aStack.stackSize < 1) return 0; + if (!aSimulate) aStack.stackSize--; + return tStats[3]; + } + long tChargeBefore = getRealCharge(aStack), tNewCharge = Math + .max(0, tChargeBefore - (aIgnoreTransferLimit ? (long) aCharge : Math.min(tStats[1], (long) aCharge))); + if (!aSimulate) setCharge(aStack, tNewCharge); + return tChargeBefore - tNewCharge; + } + + @Override + public final double getCharge(ItemStack aStack) { + return getRealCharge(aStack); + } + + @Override + public final boolean canUse(ItemStack aStack, double aAmount) { + return getRealCharge(aStack) >= aAmount; + } + + @Override + public final boolean use(ItemStack aStack, double aAmount, EntityLivingBase aPlayer) { + chargeFromArmor(aStack, aPlayer); + if (aPlayer instanceof EntityPlayer && ((EntityPlayer) aPlayer).capabilities.isCreativeMode) return true; + double tTransfer = discharge(aStack, aAmount, Integer.MAX_VALUE, true, false, true); + if (Math.abs(tTransfer - aAmount) < .0000001) { + discharge(aStack, aAmount, Integer.MAX_VALUE, true, false, false); + chargeFromArmor(aStack, aPlayer); + return true; + } + discharge(aStack, aAmount, Integer.MAX_VALUE, true, false, false); + chargeFromArmor(aStack, aPlayer); + return false; + } + + @Override + public final void chargeFromArmor(ItemStack aStack, EntityLivingBase aPlayer) { + if (aPlayer == null || aPlayer.worldObj.isRemote) return; + for (int i = 1; i < 5; i++) { + ItemStack tArmor = aPlayer.getEquipmentInSlot(i); + if (GT_ModHandler.isElectricItem(tArmor)) { + IElectricItem tArmorItem = (IElectricItem) tArmor.getItem(); + if (tArmorItem.canProvideEnergy(tArmor) && tArmorItem.getTier(tArmor) >= getTier(aStack)) { + double tCharge = ElectricItem.manager.discharge( + tArmor, + charge(aStack, Integer.MAX_VALUE - 1, Integer.MAX_VALUE, true, true), + Integer.MAX_VALUE, + true, + true, + false); + if (tCharge > 0) { + charge(aStack, tCharge, Integer.MAX_VALUE, true, false); + if (aPlayer instanceof EntityPlayer) { + Container tContainer = ((EntityPlayer) aPlayer).openContainer; + if (tContainer != null) tContainer.detectAndSendChanges(); + } + } + } + } + } + } + + /* + * @Override public final int getMaxCharge(ItemStack aStack) { Long[] tStats = getElectricStats(aStack); if (tStats + * == null) return 0; return (int)Math.abs(tStats[0]); } + * @Override public final int getTransferLimit(ItemStack aStack) { Long[] tStats = getElectricStats(aStack); if + * (tStats == null) return 0; return (int)Math.max(tStats[1], tStats[3]); } + * @Override public final int charge(ItemStack aStack, int aCharge, int aTier, boolean aIgnoreTransferLimit, boolean + * aSimulate) { Long[] tStats = getElectricStats(aStack); if (tStats == null || tStats[2] > aTier || !(tStats[3] == + * -1 || tStats[3] == -3 || (tStats[3] < 0 && aCharge == Integer.MAX_VALUE)) || aStack.stackSize != 1) return 0; + * long tChargeBefore = getRealCharge(aStack), tNewCharge = + * aCharge==Integer.MAX_VALUE?Long.MAX_VALUE:Math.min(Math.abs(tStats[0]), tChargeBefore + + * (aIgnoreTransferLimit?aCharge:Math.min(tStats[1], aCharge))); if (!aSimulate) setCharge(aStack, tNewCharge); + * return (int)(tNewCharge-tChargeBefore); } + * @Override public final int discharge(ItemStack aStack, int aCharge, int aTier, boolean aIgnoreTransferLimit, + * boolean aSimulate) { Long[] tStats = getElectricStats(aStack); if (tStats == null || tStats[2] > aTier) return 0; + * if (tStats[3] > 0) { if (aCharge < tStats[3] || aStack.stackSize < 1) return 0; if (!aSimulate) + * aStack.stackSize--; return (int)(long)tStats[3]; } long tChargeBefore = getRealCharge(aStack), tNewCharge = + * Math.max(0, tChargeBefore - (aIgnoreTransferLimit?aCharge:Math.min(tStats[1], aCharge))); if (!aSimulate) + * setCharge(aStack, tNewCharge); return (int)(tChargeBefore-tNewCharge); } + * @Override public final int getCharge(ItemStack aStack) { return (int)Math.min(Integer.MAX_VALUE, + * getRealCharge(aStack)); } + * @Override public final boolean canUse(ItemStack aStack, int aAmount) { return getRealCharge(aStack) >= aAmount; } + * @Override public final boolean use(ItemStack aStack, int aAmount, EntityLivingBase aPlayer) { + * chargeFromArmor(aStack, aPlayer); if (aPlayer instanceof EntityPlayer && + * ((EntityPlayer)aPlayer).capabilities.isCreativeMode) return true; int tTransfer = discharge(aStack, aAmount, + * Integer.MAX_VALUE, true, true); if (tTransfer == aAmount) { discharge(aStack, aAmount, Integer.MAX_VALUE, true, + * false); chargeFromArmor(aStack, aPlayer); return true; } discharge(aStack, aAmount, Integer.MAX_VALUE, true, + * false); chargeFromArmor(aStack, aPlayer); return false; } + * @Override public final void chargeFromArmor(ItemStack aStack, EntityLivingBase aPlayer) { if (aPlayer == null || + * aPlayer.worldObj.isRemote) return; for (int i = 1; i < 5; i++) { ItemStack tArmor = + * aPlayer.getEquipmentInSlot(i); if (GT_ModHandler.isElectricItem(tArmor)) { IElectricItem tArmorItem = + * (IElectricItem)tArmor.getItem(); if (tArmorItem.canProvideEnergy(tArmor) && tArmorItem.getTier(tArmor) >= + * getTier(aStack)) { int tCharge = ElectricItem.manager.discharge(tArmor, charge(aStack, Integer.MAX_VALUE-1, + * Integer.MAX_VALUE, true, true), Integer.MAX_VALUE, true, false); if (tCharge > 0) { charge(aStack, tCharge, + * Integer.MAX_VALUE, true, false); if (aPlayer instanceof EntityPlayer) { Container tContainer = + * ((EntityPlayer)aPlayer).openContainer; if (tContainer != null) tContainer.detectAndSendChanges(); } } } } } } + */ + public final long getRealCharge(ItemStack aStack) { + Long[] tStats = getElectricStats(aStack); + if (tStats == null) return 0; + if (tStats[3] > 0) return (int) (long) tStats[3]; + NBTTagCompound tNBT = aStack.getTagCompound(); + return tNBT == null ? 0 : tNBT.getLong("GT.ItemCharge"); + } + + public final boolean setCharge(ItemStack aStack, long aCharge) { + Long[] tStats = getElectricStats(aStack); + if (tStats == null || tStats[3] > 0) return false; + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) tNBT = new NBTTagCompound(); + tNBT.removeTag("GT.ItemCharge"); + aCharge = Math.min(tStats[0] < 0 ? Math.abs(tStats[0] / 2) : aCharge, Math.abs(tStats[0])); + if (aCharge > 0) { + aStack.setItemDamage(getChargedMetaData(aStack)); + tNBT.setLong("GT.ItemCharge", aCharge); + } else { + aStack.setItemDamage(getEmptyMetaData(aStack)); + } + if (tNBT.hasNoTags()) aStack.setTagCompound(null); + else aStack.setTagCompound(tNBT); + isItemStackUsable(aStack); + return true; + } + + public short getChargedMetaData(ItemStack aStack) { + return (short) aStack.getItemDamage(); + } + + public short getEmptyMetaData(ItemStack aStack) { + return (short) aStack.getItemDamage(); + } + + @Override + public FluidStack getFluid(ItemStack aStack) { + return getFluidContent(aStack); + } + + @Override + public int getCapacity(ItemStack aStack) { + Long[] tStats = getFluidContainerStats(aStack); + return tStats == null ? 0 : (int) Math.max(0, tStats[0]); + } + + @Override + public int fill(ItemStack aStack, FluidStack aFluid, boolean doFill) { + if (aStack == null || aStack.stackSize != 1) return 0; + + ItemStack tStack = GT_Utility.fillFluidContainer(aFluid, aStack, false, false); + if (tStack != null) { + aStack.setItemDamage(tStack.getItemDamage()); + aStack.func_150996_a(tStack.getItem()); + return GT_Utility.getFluidForFilledItem(tStack, false).amount; + } + + Long[] tStats = getFluidContainerStats(aStack); + if (tStats == null || tStats[0] <= 0 + || aFluid == null + || aFluid.getFluid() + .getID() <= 0 + || aFluid.amount <= 0) return 0; + + FluidStack tFluid = getFluidContent(aStack); + + if (tFluid == null || tFluid.getFluid() + .getID() <= 0) { + if (aFluid.amount <= tStats[0]) { + if (doFill) { + setFluidContent(aStack, aFluid); + } + return aFluid.amount; + } + if (doFill) { + tFluid = aFluid.copy(); + tFluid.amount = (int) (long) tStats[0]; + setFluidContent(aStack, tFluid); + } + return (int) (long) tStats[0]; + } + + if (!tFluid.isFluidEqual(aFluid)) return 0; + + int space = (int) (long) tStats[0] - tFluid.amount; + if (aFluid.amount <= space) { + if (doFill) { + tFluid.amount += aFluid.amount; + setFluidContent(aStack, tFluid); + } + return aFluid.amount; + } + if (doFill) { + tFluid.amount = (int) (long) tStats[0]; + setFluidContent(aStack, tFluid); + } + return space; + } + + @Override + public FluidStack drain(ItemStack aStack, int maxDrain, boolean doDrain) { + if (aStack == null || aStack.stackSize != 1) return null; + + FluidStack tFluid = GT_Utility.getFluidForFilledItem(aStack, false); + if (tFluid != null && maxDrain >= tFluid.amount) { + ItemStack tStack = GT_Utility.getContainerItem(aStack, false); + if (tStack == null) { + if (doDrain) aStack.stackSize = 0; + return tFluid; + } + if (doDrain) { + aStack.setItemDamage(tStack.getItemDamage()); + aStack.func_150996_a(tStack.getItem()); + } + return tFluid; + } + + Long[] tStats = getFluidContainerStats(aStack); + if (tStats == null || tStats[0] <= 0) return null; + + tFluid = getFluidContent(aStack); + if (tFluid == null) return null; + + int used = maxDrain; + if (tFluid.amount < used) used = tFluid.amount; + if (doDrain) { + tFluid.amount -= used; + setFluidContent(aStack, tFluid); + } + + FluidStack drained = tFluid.copy(); + drained.amount = used; + return drained; + } + + public FluidStack getFluidContent(ItemStack aStack) { + Long[] tStats = getFluidContainerStats(aStack); + if (tStats == null || tStats[0] <= 0) return GT_Utility.getFluidForFilledItem(aStack, false); + NBTTagCompound tNBT = aStack.getTagCompound(); + return tNBT == null ? null : FluidStack.loadFluidStackFromNBT(tNBT.getCompoundTag("GT.FluidContent")); + } + + public void setFluidContent(ItemStack aStack, FluidStack aFluid) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) tNBT = new NBTTagCompound(); + else tNBT.removeTag("GT.FluidContent"); + if (aFluid != null && aFluid.amount > 0) + tNBT.setTag("GT.FluidContent", aFluid.writeToNBT(new NBTTagCompound())); + if (tNBT.hasNoTags()) aStack.setTagCompound(null); + else aStack.setTagCompound(tNBT); + isItemStackUsable(aStack); + } + + @Override + public int getItemStackLimit(ItemStack aStack) { + Long[] tStats = getElectricStats(aStack); + if (tStats != null && (tStats[3] == -1 || tStats[3] == -2 || tStats[3] == -3) && getRealCharge(aStack) > 0) + return 1; + tStats = getFluidContainerStats(aStack); + if (tStats != null) return (int) (long) tStats[1]; + if (getDamage(aStack) == 32763) return 1; + return 64; + } + + @Override + public final Item getChargedItem(ItemStack itemStack) { + return this; + } + + @Override + public final Item getEmptyItem(ItemStack itemStack) { + return this; + } + + @Override + public final int getTier(ItemStack aStack) { + Long[] tStats = getElectricStats(aStack); + return (int) (tStats == null ? Integer.MAX_VALUE : tStats[2]); + } + + @Override + public final String getToolTip(ItemStack aStack) { + return null; + } // This has its own ToolTip Handler, no need to let the IC2 Handler screw us up at this Point + + @Override + public final IElectricItemManager getManager(ItemStack aStack) { + return this; + } // We are our own Manager + + @Override + public final boolean getShareTag() { + return true; + } // just to be sure. + + @Override + public int getItemEnchantability() { + return 0; + } + + @Override + public boolean isBookEnchantable(ItemStack aStack, ItemStack aBook) { + return false; + } + + @Override + public boolean getIsRepairable(ItemStack aStack, ItemStack aMaterial) { + return false; + } +} diff --git a/src/main/java/gregtech/api/items/GT_MetaGenerated_Item.java b/src/main/java/gregtech/api/items/GT_MetaGenerated_Item.java new file mode 100644 index 0000000000..465c4bc9d6 --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_MetaGenerated_Item.java @@ -0,0 +1,415 @@ +package gregtech.api.items; + +import static gregtech.api.enums.GT_Values.D1; +import static gregtech.api.enums.Mods.AppleCore; +import static gregtech.api.enums.Mods.GregTech; +import static gregtech.api.recipe.RecipeMaps.cannerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.BitSet; +import java.util.List; +import java.util.concurrent.ConcurrentHashMap; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.EnumAction; +import net.minecraft.item.Item; +import net.minecraft.item.ItemFood; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; + +import cpw.mods.fml.common.Optional; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.Mods; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TC_Aspects.TC_AspectStack; +import gregtech.api.interfaces.IFoodStat; +import gregtech.api.interfaces.IGT_ItemWithMaterialRenderer; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.IItemBehaviour; +import gregtech.api.interfaces.IItemContainer; +import gregtech.api.objects.ItemData; +import gregtech.api.util.GT_Config; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.render.items.GT_GeneratedMaterial_Renderer; +import squeek.applecore.api.food.FoodValues; +import squeek.applecore.api.food.IEdible; +import squeek.applecore.api.food.ItemFoodProxy; + +/** + * @author Gregorius Techneticies + * <p/> + * One Item for everything! + * <p/> + * This brilliant Item Class is used for automatically generating all possible variations of Material Items, + * like Dusts, Ingots, Gems, Plates and similar. It saves me a ton of work, when adding Items, because I always + * have to make a new Item SubType for each OreDict Prefix, when adding a new Material. + * <p/> + * As you can see, up to 32766 Items can be generated using this Class. And the last 766 Items can be custom + * defined, just to save space and MetaData. + * <p/> + * These Items can also have special RightClick abilities, electric Charge or even be set to become a Food alike + * Item. + */ +@Optional.Interface(iface = "squeek.applecore.api.food.IEdible", modid = Mods.Names.APPLE_CORE) +public abstract class GT_MetaGenerated_Item extends GT_MetaBase_Item implements IGT_ItemWithMaterialRenderer, IEdible { + + /** + * All instances of this Item Class are listed here. This gets used to register the Renderer to all Items of this + * Type, if useStandardMetaItemRenderer() returns true. + * <p/> + * You can also use the unlocalized Name gotten from getUnlocalizedName() as Key if you want to get a specific Item. + */ + public static final ConcurrentHashMap<String, GT_MetaGenerated_Item> sInstances = new ConcurrentHashMap<>(); + + /* ---------- CONSTRUCTOR AND MEMBER VARIABLES ---------- */ + + public final short mOffset, mItemAmount; + public final BitSet mEnabledItems; + public final BitSet mVisibleItems; + public final IIcon[][] mIconList; + + public final ConcurrentHashMap<Short, IFoodStat> mFoodStats = new ConcurrentHashMap<>(); + public final ConcurrentHashMap<Short, Long[]> mElectricStats = new ConcurrentHashMap<>(); + public final ConcurrentHashMap<Short, Long[]> mFluidContainerStats = new ConcurrentHashMap<>(); + public final ConcurrentHashMap<Short, Short> mBurnValues = new ConcurrentHashMap<>(); + + /** + * Creates the Item using these Parameters. + * + * @param aUnlocalized The Unlocalized Name of this Item. + */ + public GT_MetaGenerated_Item(String aUnlocalized, short aOffset, short aItemAmount) { + super(aUnlocalized); + setCreativeTab(GregTech_API.TAB_GREGTECH_MATERIALS); + setHasSubtypes(true); + setMaxDamage(0); + mEnabledItems = new BitSet(aItemAmount); + mVisibleItems = new BitSet(aItemAmount); + + mOffset = (short) Math.min(32766, aOffset); + mItemAmount = (short) Math.min(aItemAmount, 32766 - mOffset); + mIconList = new IIcon[aItemAmount][1]; + + sInstances.put(getUnlocalizedName(), this); + } + + /** + * This adds a Custom Item to the ending Range. + * + * @param aID The Id of the assigned Item [0 - mItemAmount] (The MetaData gets auto-shifted by +mOffset) + * @param aEnglish The Default Localized Name of the created Item + * @param aToolTip The Default ToolTip of the created Item, you can also insert null for having no ToolTip + * @param aRandomData The OreDict Names you want to give the Item. Also used for TC Aspects and some other things. + * @return An ItemStack containing the newly created Item. + */ + public final ItemStack addItem(int aID, String aEnglish, String aToolTip, Object... aRandomData) { + if (aToolTip == null) aToolTip = ""; + if (aID >= 0 && aID < mItemAmount) { + ItemStack rStack = new ItemStack(this, 1, mOffset + aID); + if (mEnabledItems.get(aID)) { + throw new IllegalArgumentException( + String.format("ID %s is already reserved for %s!", aID, rStack.getDisplayName())); + } + mEnabledItems.set(aID); + mVisibleItems.set(aID); + GT_LanguageManager.addStringLocalization(getUnlocalizedName(rStack) + ".name", aEnglish); + GT_LanguageManager.addStringLocalization(getUnlocalizedName(rStack) + ".tooltip", aToolTip); + List<TC_AspectStack> tAspects = new ArrayList<>(); + // Important Stuff to do first + for (Object tRandomData : aRandomData) if (tRandomData instanceof SubTag) { + if (tRandomData == SubTag.INVISIBLE) { + mVisibleItems.set(aID, false); + continue; + } + if (tRandomData == SubTag.NO_UNIFICATION) { + GT_OreDictUnificator.addToBlacklist(rStack); + } + } + // now check for the rest + for (Object tRandomData : aRandomData) if (tRandomData != null) { + boolean tUseOreDict = true; + if (tRandomData instanceof IFoodStat) { + setFoodBehavior(mOffset + aID, (IFoodStat) tRandomData); + if (((IFoodStat) tRandomData).getFoodAction(this, rStack) == EnumAction.eat) { + int tFoodValue = ((IFoodStat) tRandomData).getFoodLevel(this, rStack, null); + if (tFoodValue > 0) { + GT_Values.RA.stdBuilder() + .itemInputs(rStack, ItemList.IC2_Food_Can_Empty.get(tFoodValue)) + .itemOutputs( + ((IFoodStat) tRandomData).isRotten(this, rStack, null) + ? ItemList.IC2_Food_Can_Spoiled.get(tFoodValue) + : ItemList.IC2_Food_Can_Filled.get(tFoodValue)) + .duration(tFoodValue * 5 * SECONDS) + .eut(1) + .addTo(cannerRecipes); + } + } + tUseOreDict = false; + } + if (tRandomData instanceof IItemBehaviour) { + // The cast below from is not safe. If you know how to make it safe, please do. + // noinspection unchecked + addItemBehavior(mOffset + aID, (IItemBehaviour<GT_MetaBase_Item>) tRandomData); + tUseOreDict = false; + } + if (tRandomData instanceof IItemContainer) { + ((IItemContainer) tRandomData).set(rStack); + tUseOreDict = false; + } + if (tRandomData instanceof SubTag) { + continue; + } + if (tRandomData instanceof TC_AspectStack) { + ((TC_AspectStack) tRandomData).addToAspectList(tAspects); + continue; + } + if (tRandomData instanceof ItemData) { + if (GT_Utility.isStringValid(tRandomData)) GT_OreDictUnificator.registerOre(tRandomData, rStack); + else GT_OreDictUnificator.addItemData(rStack, (ItemData) tRandomData); + continue; + } + if (tUseOreDict) { + GT_OreDictUnificator.registerOre(tRandomData, rStack); + } + } + if (GregTech_API.sThaumcraftCompat != null) + GregTech_API.sThaumcraftCompat.registerThaumcraftAspectsToItem(rStack, tAspects, false); + return rStack; + } + return null; + } + + /** + * Sets a Food Behavior for the Item. + * + * @param aMetaValue the Meta Value of the Item you want to set it to. [0 - 32765] + * @param aFoodBehavior the Food Behavior you want to add. + * @return the Item itself for convenience in constructing. + */ + public final GT_MetaGenerated_Item setFoodBehavior(int aMetaValue, IFoodStat aFoodBehavior) { + if (aMetaValue < 0 || aMetaValue >= mOffset + mEnabledItems.length()) return this; + if (aFoodBehavior == null) mFoodStats.remove((short) aMetaValue); + else mFoodStats.put((short) aMetaValue, aFoodBehavior); + return this; + } + + /** + * Sets the Furnace Burn Value for the Item. + * + * @param aMetaValue the Meta Value of the Item you want to set it to. [0 - 32765] + * @param aValue 200 = 1 Burn Process = 500 EU, max = 32767 (that is 81917.5 EU) + * @return the Item itself for convenience in constructing. + */ + public final GT_MetaGenerated_Item setBurnValue(int aMetaValue, int aValue) { + if (aMetaValue < 0 || aMetaValue >= mOffset + mEnabledItems.length() || aValue < 0) return this; + if (aValue == 0) mBurnValues.remove((short) aMetaValue); + else mBurnValues.put((short) aMetaValue, aValue > Short.MAX_VALUE ? Short.MAX_VALUE : (short) aValue); + return this; + } + + /** + * @param aMetaValue the Meta Value of the Item you want to set it to. [0 - 32765] + * @param aMaxCharge Maximum Charge. (if this is == 0 it will remove the Electric Behavior) + * @param aTransferLimit Transfer Limit. + * @param aTier The electric Tier. + * @param aSpecialData If this Item has a Fixed Charge, like a SingleUse Battery (if > 0). Use -1 if you want to + * make this Battery chargeable (the use and canUse Functions will still discharge if you just + * use this) Use -2 if you want to make this Battery dischargeable. Use -3 if you want to make + * this Battery charge/discharge-able. + * @return the Item itself for convenience in constructing. + */ + public final GT_MetaGenerated_Item setElectricStats(int aMetaValue, long aMaxCharge, long aTransferLimit, + long aTier, long aSpecialData, boolean aUseAnimations) { + if (aMetaValue < 0 || aMetaValue >= mOffset + mEnabledItems.length()) return this; + if (aMaxCharge == 0) mElectricStats.remove((short) aMetaValue); + else { + mElectricStats.put( + (short) aMetaValue, + new Long[] { aMaxCharge, Math.max(0, aTransferLimit), Math.max(-1, aTier), aSpecialData }); + if (aMetaValue >= mOffset && aUseAnimations) mIconList[aMetaValue - mOffset] = Arrays + .copyOf(mIconList[aMetaValue - mOffset], Math.max(9, mIconList[aMetaValue - mOffset].length)); + } + return this; + } + + /** + * + * @param aMetaValue the Meta Value of the Item you want to set it to. [0 - 32765] + * @param aCapacity fluid capacity in L or mb + * @param aStacksize item stack size + * @return the Item itself for convenience in constructing. + */ + public final GT_MetaGenerated_Item setFluidContainerStats(int aMetaValue, long aCapacity, long aStacksize) { + if (aMetaValue < 0 || aMetaValue >= mOffset + mEnabledItems.length()) return this; + if (aCapacity < 0) mElectricStats.remove((short) aMetaValue); + else mFluidContainerStats.put((short) aMetaValue, new Long[] { aCapacity, Math.max(1, aStacksize) }); + return this; + } + + /** + * @return if this MetaGenerated Item should use my Default Renderer System. + */ + public boolean useStandardMetaItemRenderer() { + return true; + } + + @Override + public short[] getRGBa(ItemStack aStack) { + return Materials._NULL.getRGBA(); + } + + /** + * @return the Icon the Material is going to be rendered with. + */ + public IIconContainer getIconContainer(int aMetaData) { + return null; + } + + @Override + public IIcon getIcon(int aMetaData, int pass) { + IIconContainer iconContainer = getIconContainer(aMetaData); + return iconContainer != null ? iconContainer.getIcon() : null; + } + + @Override + public IIcon getOverlayIcon(int aMetaData, int pass) { + IIconContainer iconContainer = getIconContainer(aMetaData); + return iconContainer != null ? iconContainer.getOverlayIcon() : null; + } + + @Override + public boolean shouldUseCustomRenderer(int aMetaData) { + return true; + } + + @Override + public GT_GeneratedMaterial_Renderer getMaterialRenderer(int aMetaData) { + return null; + } + + @Override + public boolean allowMaterialRenderer(int aMetaData) { + return aMetaData < this.mOffset; + } + + /* ---------- INTERNAL OVERRIDES ---------- */ + + @Override + public ItemStack onItemRightClick(ItemStack aStack, World aWorld, EntityPlayer aPlayer) { + IFoodStat tStat = mFoodStats.get((short) getDamage(aStack)); + if (tStat != null && aPlayer.canEat(tStat.alwaysEdible(this, aStack, aPlayer))) + aPlayer.setItemInUse(aStack, 32); + return super.onItemRightClick(aStack, aWorld, aPlayer); + } + + @Override + public int getMaxItemUseDuration(ItemStack aStack) { + return mFoodStats.get((short) getDamage(aStack)) == null ? 0 : 32; + } + + @Override + public EnumAction getItemUseAction(ItemStack aStack) { + IFoodStat tStat = mFoodStats.get((short) getDamage(aStack)); + return tStat == null ? EnumAction.none : tStat.getFoodAction(this, aStack); + } + + @Override + public final ItemStack onEaten(ItemStack aStack, World aWorld, EntityPlayer aPlayer) { + IFoodStat tStat = mFoodStats.get((short) getDamage(aStack)); + if (tStat != null) { + if (AppleCore.isModLoaded()) { + aPlayer.getFoodStats() + .func_151686_a(getFoodProxy(this), aStack); + } else { + aPlayer.getFoodStats() + .addStats(tStat.getFoodLevel(this, aStack, aPlayer), tStat.getSaturation(this, aStack, aPlayer)); + } + tStat.onEaten(this, aStack, aPlayer); + } + return aStack; + } + + @Optional.Method(modid = Mods.Names.APPLE_CORE) + private static ItemFood getFoodProxy(Object edible) { + return new ItemFoodProxy((IEdible) edible); + } + + @Override + @Optional.Method(modid = Mods.Names.APPLE_CORE) + public FoodValues getFoodValues(ItemStack aStack) { + IFoodStat tStat = mFoodStats.get((short) getDamage(aStack)); + return tStat == null ? null + : new FoodValues(tStat.getFoodLevel(this, aStack, null), tStat.getSaturation(this, aStack, null)); + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item aItem, CreativeTabs aCreativeTab, List<ItemStack> aList) { + int j = mEnabledItems.length(); + for (int i = 0; i < j; i++) if (mVisibleItems.get(i) || (D1 && mEnabledItems.get(i))) { + Long[] tStats = mElectricStats.get((short) (mOffset + i)); + if (tStats != null && tStats[3] < 0) { + ItemStack tStack = new ItemStack(this, 1, mOffset + i); + setCharge(tStack, Math.abs(tStats[0])); + isItemStackUsable(tStack); + aList.add(tStack); + } + if (tStats == null || tStats[3] != -2) { + ItemStack tStack = new ItemStack(this, 1, mOffset + i); + isItemStackUsable(tStack); + aList.add(tStack); + } + } + } + + @Override + @SideOnly(Side.CLIENT) + public final void registerIcons(IIconRegister aIconRegister) { + short j = (short) mEnabledItems.length(); + for (short i = 0; i < j; i++) if (mEnabledItems.get(i)) { + for (byte k = 1; k < mIconList[i].length; k++) { + mIconList[i][k] = aIconRegister.registerIcon( + GregTech.getResourcePath(GT_Config.troll ? "troll" : getUnlocalizedName() + "/" + i + "/" + k)); + } + mIconList[i][0] = aIconRegister + .registerIcon(GregTech.getResourcePath(GT_Config.troll ? "troll" : getUnlocalizedName() + "/" + i)); + } + } + + @Override + public final Long[] getElectricStats(ItemStack aStack) { + return mElectricStats.get((short) aStack.getItemDamage()); + } + + @Override + public final Long[] getFluidContainerStats(ItemStack aStack) { + return mFluidContainerStats.get((short) aStack.getItemDamage()); + } + + @Override + public int getItemEnchantability() { + return 0; + } + + @Override + public boolean isBookEnchantable(ItemStack aStack, ItemStack aBook) { + return false; + } + + @Override + public boolean getIsRepairable(ItemStack aStack, ItemStack aMaterial) { + return false; + } +} diff --git a/src/main/java/gregtech/api/items/GT_MetaGenerated_Item_X01.java b/src/main/java/gregtech/api/items/GT_MetaGenerated_Item_X01.java new file mode 100644 index 0000000000..db41a3c35b --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_MetaGenerated_Item_X01.java @@ -0,0 +1,213 @@ +package gregtech.api.items; + +import static gregtech.api.enums.GT_Values.M; + +import java.util.List; + +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTech_API; +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_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +/** + * @author Gregorius Techneticies + * <p/> + * One Item for everything! + * <p/> + * This brilliant Item Class is used for automatically generating all possible variations of Material Items, + * like Dusts, Ingots, Gems, Plates and similar. It saves me a ton of work, when adding Items, because I always + * have to make a new Item SubType for each OreDict Prefix, when adding a new Material. + * <p/> + * As you can see, up to 32766 Items can be generated using this Class. And the last 766 Items can be custom + * defined, just to save space and MetaData. + * <p/> + * These Items can also have special RightClick abilities, electric Charge or even be set to become a Food alike + * Item. + */ +public abstract class GT_MetaGenerated_Item_X01 extends GT_MetaGenerated_Item { + + protected final OrePrefixes mPrefix; + protected final int mIconSetIndex; + + /** + * Creates the Item using these Parameters. This is for the new 1 Item = 1 Prefix System. + * + * @param aUnlocalized The Unlocalized Name of this Item. + * @param aGeneratedPrefix The OreDict Prefix you want to have generated. + * @param aIconSetIndex The TextureSet Index to be used. -1 for Defaulting to the Data contained in the Prefix. + * (this is only to be used for selecting the Icon in getIconContainer, nothing else) + */ + public GT_MetaGenerated_Item_X01(String aUnlocalized, OrePrefixes aGeneratedPrefix, int aIconSetIndex) { + super(aUnlocalized, (short) 32000, (short) 766); + mPrefix = aGeneratedPrefix; + mIconSetIndex = aIconSetIndex >= 0 ? aIconSetIndex + : aGeneratedPrefix.mTextureIndex >= 0 ? aGeneratedPrefix.mTextureIndex : 0; + + for (int i = 0; i < GregTech_API.sGeneratedMaterials.length; i++) { + OrePrefixes tPrefix = mPrefix; + if (tPrefix == null) continue; + Materials tMaterial = GregTech_API.sGeneratedMaterials[i]; + if (tMaterial == null) continue; + if (mPrefix.doGenerateItem(tMaterial)) { + ItemStack tStack = new ItemStack(this, 1, i); + GT_LanguageManager.addStringLocalization( + getUnlocalizedName(tStack) + ".name", + GT_LanguageManager.i18nPlaceholder ? getDefaultLocalizationFormat(tPrefix, tMaterial, i) + : getDefaultLocalization(tPrefix, tMaterial, i)); + GT_LanguageManager.addStringLocalization( + getUnlocalizedName(tStack) + ".tooltip", + tMaterial.getToolTip(tPrefix.mMaterialAmount / M)); + String tOreName = getOreDictString(tPrefix, tMaterial); + tPrefix = OrePrefixes.getOrePrefix(tOreName); + if (tPrefix != null && tPrefix.mIsUnificatable) { + GT_OreDictUnificator.set(tPrefix, OrePrefixes.getMaterial(tOreName, tPrefix), tStack); + } else { + GT_OreDictUnificator.registerOre(tOreName, tStack); + } + } + } + } + + /* ---------- OVERRIDEABLE FUNCTIONS ---------- */ + + /** + * @param aPrefix the OreDict Prefix + * @param aMaterial the Material + * @param aMetaData a Index from [0 - 31999] + * @return the Localized Name when default LangFiles are used. + */ + public String getDefaultLocalization(OrePrefixes aPrefix, Materials aMaterial, int aMetaData) { + return aPrefix.getDefaultLocalNameForItem(aMaterial); + } + + /** + * @param aPrefix the OreDict Prefix + * @param aMaterial the Material + * @param aMetaData a Index from [0 - 31999] + * @return the Localized Name Format when default LangFiles are used. + */ + public String getDefaultLocalizationFormat(OrePrefixes aPrefix, Materials aMaterial, int aMetaData) { + return aPrefix.getDefaultLocalNameFormatForItem(aMaterial); + } + + /** + * @param aPrefix always != null + * @param aMaterial always != null + * @param aDoShowAllItems this is the Configuration Setting of the User, if he wants to see all the Stuff like Tiny + * Dusts or Crushed Ores as well. + * @return if this Item should be visible in NEI or Creative + */ + public boolean doesShowInCreative(OrePrefixes aPrefix, Materials aMaterial, boolean aDoShowAllItems) { + return true; + } + + /** + * @return the name of the Item to be registered at the OreDict. + */ + public String getOreDictString(OrePrefixes aPrefix, Materials aMaterial) { + return aPrefix.get(aMaterial) + .toString(); + } + + public IIconContainer getIconContainer(int aMetaData, Materials aMaterial) { + return aMaterial.mIconSet.mTextures[mIconSetIndex]; + } + + /* ---------- INTERNAL OVERRIDES ---------- */ + + @Override + public String getItemStackDisplayName(ItemStack aStack) { + String aName = super.getItemStackDisplayName(aStack); + int aDamage = aStack.getItemDamage(); + if (aDamage < 32000 && aDamage >= 0) return Materials.getLocalizedNameForItem(aName, aDamage % 1000); + return aName; + } + + @Override + public ItemStack getContainerItem(ItemStack aStack) { + int aMetaData = aStack.getItemDamage(); + if (aMetaData < GregTech_API.sGeneratedMaterials.length && aMetaData >= 0) { + Materials aMaterial = GregTech_API.sGeneratedMaterials[aMetaData]; + if (aMaterial != null && aMaterial != Materials.Empty && aMaterial != Materials._NULL) { + return GT_Utility.copyAmount(1, mPrefix.mContainerItem); + } + } + return null; + } + + @Override + public short[] getRGBa(ItemStack aStack) { + int aMetaData = getDamage(aStack); + return aMetaData < GregTech_API.sGeneratedMaterials.length + && GregTech_API.sGeneratedMaterials[aMetaData] != null ? GregTech_API.sGeneratedMaterials[aMetaData].mRGBa + : Materials._NULL.mRGBa; + } + + @Override + public final IIconContainer getIconContainer(int aMetaData) { + return aMetaData < GregTech_API.sGeneratedMaterials.length + && GregTech_API.sGeneratedMaterials[aMetaData] != null + ? getIconContainer(aMetaData, GregTech_API.sGeneratedMaterials[aMetaData]) + : null; + } + + @Override + @SideOnly(Side.CLIENT) + public final void getSubItems(Item aItem, CreativeTabs aCreativeTab, List<ItemStack> aList) { + for (int i = 0; i < GregTech_API.sGeneratedMaterials.length; i++) + if (mPrefix.doGenerateItem(GregTech_API.sGeneratedMaterials[i]) && doesShowInCreative( + mPrefix, + GregTech_API.sGeneratedMaterials[i], + GregTech_API.sDoShowAllItemsInCreative)) { + ItemStack tStack = new ItemStack(this, 1, i); + isItemStackUsable(tStack); + aList.add(tStack); + } + super.getSubItems(aItem, aCreativeTab, aList); + } + + @Override + public final IIcon getIconFromDamage(int aMetaData) { + if (aMetaData < 0) return null; + if (aMetaData < GregTech_API.sGeneratedMaterials.length) { + Materials tMaterial = GregTech_API.sGeneratedMaterials[aMetaData]; + if (tMaterial == null) return null; + IIconContainer tIcon = getIconContainer(aMetaData, tMaterial); + if (tIcon != null) return tIcon.getIcon(); + return null; + } + return aMetaData >= mOffset && aMetaData - mOffset < mIconList.length ? mIconList[aMetaData - mOffset][0] + : null; + } + + @Override + public int getItemStackLimit(ItemStack aStack) { + return getDamage(aStack) < mOffset ? Math.min(super.getItemStackLimit(aStack), mPrefix.mDefaultStackSize) + : super.getItemStackLimit(aStack); + } + + @Override + public int getItemEnchantability() { + return 0; + } + + @Override + public boolean isBookEnchantable(ItemStack aStack, ItemStack aBook) { + return false; + } + + @Override + public boolean getIsRepairable(ItemStack aStack, ItemStack aMaterial) { + return false; + } +} diff --git a/src/main/java/gregtech/api/items/GT_MetaGenerated_Item_X32.java b/src/main/java/gregtech/api/items/GT_MetaGenerated_Item_X32.java new file mode 100644 index 0000000000..c344397e4e --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_MetaGenerated_Item_X32.java @@ -0,0 +1,225 @@ +package gregtech.api.items; + +import static gregtech.api.enums.GT_Values.M; + +import java.util.Arrays; +import java.util.List; + +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTech_API; +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 gregtech.api.util.GT_Utility; +import gregtech.common.render.items.GT_GeneratedMaterial_Renderer; + +/** + * @author Gregorius Techneticies + * <p/> + * One Item for everything! + * <p/> + * This brilliant Item Class is used for automatically generating all possible variations of Material Items, + * like Dusts, Ingots, Gems, Plates and similar. It saves me a ton of work, when adding Items, because I always + * have to make a new Item SubType for each OreDict Prefix, when adding a new Material. + * <p/> + * As you can see, up to 32766 Items can be generated using this Class. And the last 766 Items can be custom + * defined, just to save space and MetaData. + * <p/> + * These Items can also have special RightClick abilities, electric Charge or even be set to become a Food alike + * Item. + */ +public abstract class GT_MetaGenerated_Item_X32 extends GT_MetaGenerated_Item { + + protected final OrePrefixes[] mGeneratedPrefixList; + + /** + * Creates the Item using these Parameters. + * + * @param aUnlocalized The Unlocalized Name of this Item. + * @param aGeneratedPrefixList The OreDict Prefixes you want to have generated. + */ + public GT_MetaGenerated_Item_X32(String aUnlocalized, OrePrefixes... aGeneratedPrefixList) { + super(aUnlocalized, (short) 32000, (short) 766); + mGeneratedPrefixList = Arrays.copyOf(aGeneratedPrefixList, 32); + + for (int i = 0; i < 32000; i++) { + OrePrefixes tPrefix = mGeneratedPrefixList[i / 1000]; + if (tPrefix == null) continue; + if (tPrefix == OrePrefixes.___placeholder___) continue; + Materials tMaterial = GregTech_API.sGeneratedMaterials[i % 1000]; + if (tMaterial == null) continue; + if (doesMaterialAllowGeneration(tPrefix, tMaterial)) { + ItemStack tStack = new ItemStack(this, 1, i); + GT_LanguageManager.addStringLocalization( + getUnlocalizedName(tStack) + ".name", + GT_LanguageManager.i18nPlaceholder ? getDefaultLocalizationFormat(tPrefix, tMaterial, i) + : getDefaultLocalization(tPrefix, tMaterial, i)); + GT_LanguageManager.addStringLocalization( + getUnlocalizedName(tStack) + ".tooltip", + tMaterial.getToolTip(tPrefix.mMaterialAmount / M)); + if (tPrefix.mIsUnificatable) { + GT_OreDictUnificator.set(tPrefix, tMaterial, tStack); + } else { + GT_OreDictUnificator.registerOre(tPrefix.get(tMaterial), tStack); + } + if ((tPrefix == OrePrefixes.stick || tPrefix == OrePrefixes.wireFine || tPrefix == OrePrefixes.ingot) + && (tMaterial == Materials.Lead || tMaterial == Materials.Tin + || tMaterial == Materials.SolderingAlloy)) { + GregTech_API.sSolderingMetalList.add(tStack); + GT_ModHandler.registerBoxableItemToToolBox(tStack); + } + } + } + } + + /* ---------- OVERRIDEABLE FUNCTIONS ---------- */ + + /** + * @return the Color Modulation the Material is going to be rendered with. + */ + @Override + public short[] getRGBa(ItemStack aStack) { + Materials tMaterial = GregTech_API.sGeneratedMaterials[getDamage(aStack) % 1000]; + return tMaterial == null ? Materials._NULL.mRGBa : tMaterial.mRGBa; + } + + /** + * @param aPrefix this can be null, you have to return false in that case + * @param aMaterial this can be null, you have to return false in that case + * @return if this Item should be generated and visible. + */ + public boolean doesMaterialAllowGeneration(OrePrefixes aPrefix, Materials aMaterial) { + // You have to check for at least these Conditions in every Case! So add a super Call like the following for + // this before executing your Code: + // if (!super.doesMaterialAllowGeneration(aPrefix, aMaterial)) return false; + return aPrefix != null && aPrefix.doGenerateItem(aMaterial); + } + + /* ---------- OVERRIDEABLE FUNCTIONS ---------- */ + + /** + * @param aPrefix the OreDict Prefix + * @param aMaterial the Material + * @param aMetaData a Index from [0 - 31999] + * @return the Localized Name when default LangFiles are used. + */ + public String getDefaultLocalization(OrePrefixes aPrefix, Materials aMaterial, int aMetaData) { + return aPrefix.getDefaultLocalNameForItem(aMaterial); + } + + /** + * @param aPrefix the OreDict Prefix + * @param aMaterial the Material + * @param aMetaData a Index from [0 - 31999] + * @return the Localized Name Format when default LangFiles are used. + */ + public String getDefaultLocalizationFormat(OrePrefixes aPrefix, Materials aMaterial, int aMetaData) { + return aPrefix.getDefaultLocalNameFormatForItem(aMaterial); + } + + /** + * @param aMetaData a Index from [0 - 31999] + * @param aMaterial the Material + * @return an Icon Container for the Item Display. + */ + public final IIconContainer getIconContainer(int aMetaData, Materials aMaterial) { + return mGeneratedPrefixList[aMetaData / 1000] != null + && mGeneratedPrefixList[aMetaData / 1000].mTextureIndex >= 0 + ? aMaterial.mIconSet.mTextures[mGeneratedPrefixList[aMetaData / 1000].mTextureIndex] + : null; + } + + /** + * @param aPrefix always != null + * @param aMaterial always != null + * @param aDoShowAllItems this is the Configuration Setting of the User, if he wants to see all the Stuff like Tiny + * Dusts or Crushed Ores as well. + * @return if this Item should be visible in NEI or Creative + */ + public boolean doesShowInCreative(OrePrefixes aPrefix, Materials aMaterial, boolean aDoShowAllItems) { + return true; + } + + /* ---------- INTERNAL OVERRIDES ---------- */ + + @Override + public String getItemStackDisplayName(ItemStack aStack) { + String aName = super.getItemStackDisplayName(aStack); + int aDamage = aStack.getItemDamage(); + if (aDamage < 32000 && aDamage >= 0) return Materials.getLocalizedNameForItem(aName, aDamage % 1000); + return aName; + } + + @Override + public ItemStack getContainerItem(ItemStack aStack) { + int aDamage = aStack.getItemDamage(); + if (aDamage < 32000 && aDamage >= 0) { + Materials aMaterial = GregTech_API.sGeneratedMaterials[aDamage % 1000]; + if (aMaterial != null && aMaterial != Materials.Empty && aMaterial != Materials._NULL) { + OrePrefixes aPrefix = mGeneratedPrefixList[aDamage / 1000]; + if (aPrefix != null) return GT_Utility.copyAmount(1, aPrefix.mContainerItem); + } + } + return null; + } + + @Override + public final IIconContainer getIconContainer(int aMetaData) { + return GregTech_API.sGeneratedMaterials[aMetaData % 1000] == null ? null + : getIconContainer(aMetaData, GregTech_API.sGeneratedMaterials[aMetaData % 1000]); + } + + @Override + public GT_GeneratedMaterial_Renderer getMaterialRenderer(int aMetaData) { + return GregTech_API.sGeneratedMaterials[aMetaData % 1000] == null ? null + : GregTech_API.sGeneratedMaterials[aMetaData % 1000].renderer; + } + + @Override + @SideOnly(Side.CLIENT) + public final void getSubItems(Item aItem, CreativeTabs aCreativeTab, List<ItemStack> aList) { + for (int i = 0; i < 32000; i++) { + OrePrefixes aPrefix = mGeneratedPrefixList[i / 1000]; + Materials aMaterial = GregTech_API.sGeneratedMaterials[i % 1000]; + if (aPrefix != null && aMaterial != null) { + if (doesMaterialAllowGeneration(aPrefix, aMaterial) + && doesShowInCreative(aPrefix, aMaterial, GregTech_API.sDoShowAllItemsInCreative)) { + ItemStack tStack = new ItemStack(this, 1, i); + isItemStackUsable(tStack); + aList.add(tStack); + } + } + } + super.getSubItems(aItem, aCreativeTab, aList); + } + + @Override + public final IIcon getIconFromDamage(int aMetaData) { + if (aMetaData < 0) return null; + if (aMetaData < 32000) { + Materials tMaterial = GregTech_API.sGeneratedMaterials[aMetaData % 1000]; + if (tMaterial == null) return null; + IIconContainer tIcon = getIconContainer(aMetaData, tMaterial); + if (tIcon != null) return tIcon.getIcon(); + return null; + } + return aMetaData - 32000 < mIconList.length ? mIconList[aMetaData - 32000][0] : null; + } + + @Override + public int getItemStackLimit(ItemStack aStack) { + int tDamage = getDamage(aStack); + if (tDamage < 32000 && mGeneratedPrefixList[tDamage / 1000] != null) + return Math.min(super.getItemStackLimit(aStack), mGeneratedPrefixList[tDamage / 1000].mDefaultStackSize); + return super.getItemStackLimit(aStack); + } +} diff --git a/src/main/java/gregtech/api/items/GT_MetaGenerated_Tool.java b/src/main/java/gregtech/api/items/GT_MetaGenerated_Tool.java new file mode 100644 index 0000000000..cec93169ec --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_MetaGenerated_Tool.java @@ -0,0 +1,1013 @@ +package gregtech.api.items; + +import static gregtech.api.util.GT_Utility.formatNumbers; +import static gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine_Steam.calculateLooseFlow; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map.Entry; +import java.util.concurrent.ConcurrentHashMap; + +import net.minecraft.block.Block; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.enchantment.Enchantment; +import net.minecraft.enchantment.EnchantmentHelper; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.SharedMonsterAttributes; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.item.EntityMinecart; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.EnumAction; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.potion.Potion; +import net.minecraft.stats.AchievementList; +import net.minecraft.stats.StatList; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.IIcon; +import net.minecraft.util.MathHelper; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; +import net.minecraftforge.common.IShearable; +import net.minecraftforge.event.entity.player.PlayerEvent; +import net.minecraftforge.event.world.BlockEvent; + +import appeng.api.implementations.items.IAEWrench; +import buildcraft.api.tools.IToolWrench; +import cpw.mods.fml.common.Mod; +import cpw.mods.fml.common.Optional; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import crazypants.enderio.api.tool.ITool; +import forestry.api.arboriculture.IToolGrafter; +import gregtech.GT_Mod; +import gregtech.api.GregTech_API; +import gregtech.api.enchants.Enchantment_Radioactivity; +import gregtech.api.enums.Materials; +import gregtech.api.enums.TC_Aspects.TC_AspectStack; +import gregtech.api.interfaces.IDamagableItem; +import gregtech.api.interfaces.IToolStats; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.tools.GT_Tool_Turbine; +import mods.railcraft.api.core.items.IToolCrowbar; +import mrtjp.projectred.api.IScrewdriver; + +/** + * This is an example on how you can create a Tool ItemStack, in this case a Bismuth Wrench: + * GT_MetaGenerated_Tool.sInstances.get("gt.metatool.01").getToolWithStats(GT_MetaGenerated_Tool_01.WRENCH, 1, + * Materials.Bismuth, Materials.Bismuth, null); + */ +@Optional.InterfaceList( + value = { + @Optional.Interface(iface = "forestry.api.arboriculture.IToolGrafter", modid = "ForestryAPI|arboriculture"), + @Optional.Interface(iface = "mods.railcraft.api.core.items.IToolCrowbar", modid = "RailcraftAPI|items"), + @Optional.Interface(iface = "buildcraft.api.tools.IToolWrench", modid = "BuildCraftAPI|tools"), + @Optional.Interface(iface = "crazypants.enderio.api.tool.ITool", modid = "EnderIOAPI|Tools"), + @Optional.Interface(iface = "mrtjp.projectred.api.IScrewdriver", modid = "ProjRed|Core"), }) +public abstract class GT_MetaGenerated_Tool extends GT_MetaBase_Item + implements IDamagableItem, IToolGrafter, IToolCrowbar, IToolWrench, ITool, IScrewdriver, IAEWrench { + + /** + * All instances of this Item Class are listed here. This gets used to register the Renderer to all Items of this + * Type, if useStandardMetaItemRenderer() returns true. + * <p/> + * You can also use the unlocalized Name gotten from getUnlocalizedName() as Key if you want to get a specific Item. + */ + public static final ConcurrentHashMap<String, GT_MetaGenerated_Tool> sInstances = new ConcurrentHashMap<>(); + + /* ---------- CONSTRUCTOR AND MEMBER VARIABLES ---------- */ + + public final ConcurrentHashMap<Short, IToolStats> mToolStats = new ConcurrentHashMap<>(); + + /** + * Creates the Item using these Parameters. + * + * @param aUnlocalized The Unlocalized Name of this Item. + */ + public GT_MetaGenerated_Tool(String aUnlocalized) { + super(aUnlocalized); + setCreativeTab(GregTech_API.TAB_GREGTECH); + setMaxStackSize(1); + sInstances.put(getUnlocalizedName(), this); + } + + /* ---------- FOR ADDING CUSTOM ITEMS INTO THE REMAINING 766 RANGE ---------- */ + + public static final Materials getPrimaryMaterial(ItemStack aStack) { + NBTTagCompound aNBT = aStack.getTagCompound(); + if (aNBT != null) { + aNBT = aNBT.getCompoundTag("GT.ToolStats"); + if (aNBT != null) return Materials.getRealMaterial(aNBT.getString("PrimaryMaterial")); + } + return Materials._NULL; + } + + public static final Materials getSecondaryMaterial(ItemStack aStack) { + NBTTagCompound aNBT = aStack.getTagCompound(); + if (aNBT != null) { + aNBT = aNBT.getCompoundTag("GT.ToolStats"); + if (aNBT != null) return Materials.getRealMaterial(aNBT.getString("SecondaryMaterial")); + } + return Materials._NULL; + } + + /* ---------- INTERNAL OVERRIDES ---------- */ + + public static final long getToolMaxDamage(ItemStack aStack) { + NBTTagCompound aNBT = aStack.getTagCompound(); + if (aNBT != null) { + aNBT = aNBT.getCompoundTag("GT.ToolStats"); + if (aNBT != null) return aNBT.getLong("MaxDamage"); + } + return 0; + } + + public static final long getToolDamage(ItemStack aStack) { + NBTTagCompound aNBT = aStack.getTagCompound(); + if (aNBT != null) { + aNBT = aNBT.getCompoundTag("GT.ToolStats"); + if (aNBT != null) return aNBT.getLong("Damage"); + } + return 0; + } + + public static final boolean setToolDamage(ItemStack aStack, long aDamage) { + NBTTagCompound aNBT = aStack.getTagCompound(); + if (aNBT != null) { + aNBT = aNBT.getCompoundTag("GT.ToolStats"); + if (aNBT != null) { + aNBT.setLong("Damage", aDamage); + return true; + } + } + return false; + } + + public static final boolean setToolMode(ItemStack aStack, byte aMode) { + NBTTagCompound aNBT = aStack.getTagCompound(); + if (aNBT != null) { + aNBT = aNBT.getCompoundTag("GT.ToolStats"); + if (aNBT != null) { + aNBT.setByte("Mode", aMode); + return true; + } + } + return false; + } + + public static final byte getToolMode(ItemStack aStack) { + NBTTagCompound aNBT = aStack.getTagCompound(); + if (aNBT != null) { + aNBT = aNBT.getCompoundTag("GT.ToolStats"); + if (aNBT != null) return aNBT.getByte("Mode"); + } + return 0; + } + + /** + * This adds a Custom Item to the ending Range. + * + * @param aID The Id of the assigned Tool Class [0 - 32765] (only even Numbers allowed! Uneven + * ID's are empty electric Items) + * @param aEnglish The Default Localized Name of the created Item + * @param aToolTip The Default ToolTip of the created Item, you can also insert null for having no + * ToolTip + * @param aToolStats The Food Value of this Item. Can be null as well. + * @param aOreDictNamesAndAspects The OreDict Names you want to give the Item. Also used to assign Thaumcraft + * Aspects. + * @return An ItemStack containing the newly created Item, but without specific Stats. + */ + public final ItemStack addTool(int aID, String aEnglish, String aToolTip, IToolStats aToolStats, + Object... aOreDictNamesAndAspects) { + if (aToolTip == null) aToolTip = ""; + if (aID >= 0 && aID < 32766 && aID % 2 == 0) { + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + "." + aID + ".name", aEnglish); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + "." + aID + ".tooltip", aToolTip); + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + "." + (aID + 1) + ".name", aEnglish + " (Empty)"); + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + "." + (aID + 1) + ".tooltip", "You need to recharge it"); + mToolStats.put((short) aID, aToolStats); + mToolStats.put((short) (aID + 1), aToolStats); + aToolStats.onStatsAddedToTool(this, aID); + ItemStack rStack = new ItemStack(this, 1, aID); + List<TC_AspectStack> tAspects = new ArrayList<>(); + for (Object tOreDictNameOrAspect : aOreDictNamesAndAspects) { + if (tOreDictNameOrAspect instanceof TC_AspectStack) + ((TC_AspectStack) tOreDictNameOrAspect).addToAspectList(tAspects); + else GT_OreDictUnificator.registerOre(tOreDictNameOrAspect, rStack); + } + if (GregTech_API.sThaumcraftCompat != null) + GregTech_API.sThaumcraftCompat.registerThaumcraftAspectsToItem(rStack, tAspects, false); + GT_ModHandler.registerBoxableItemToToolBox(rStack); + return rStack; + } + return null; + } + + /** + * This Function gets an ItemStack Version of this Tool + * + * @param aToolID the ID of the Tool Class + * @param aAmount Amount of Items (well normally you only need 1) + * @param aPrimaryMaterial Primary Material of this Tool + * @param aSecondaryMaterial Secondary (Rod/Handle) Material of this Tool + * @param aElectricArray The Electric Stats of this Tool (or null if not electric) + */ + public final ItemStack getToolWithStats(int aToolID, int aAmount, Materials aPrimaryMaterial, + Materials aSecondaryMaterial, long[] aElectricArray) { + ItemStack rStack = new ItemStack(this, aAmount, aToolID); + IToolStats tToolStats = getToolStats(rStack); + if (tToolStats != null) { + NBTTagCompound tMainNBT = new NBTTagCompound(), tToolNBT = new NBTTagCompound(); + tToolNBT.setByte("Mode", (byte) 0); + if (aPrimaryMaterial != null) { + tToolNBT.setString("PrimaryMaterial", aPrimaryMaterial.mName); + tToolNBT.setLong( + "MaxDamage", + 100L * (long) (aPrimaryMaterial.mDurability * tToolStats.getMaxDurabilityMultiplier())); + } + if (aSecondaryMaterial != null) tToolNBT.setString("SecondaryMaterial", aSecondaryMaterial.mName); + + if (aElectricArray != null) { + tToolNBT.setBoolean("Electric", true); + tToolNBT.setLong("MaxCharge", aElectricArray[0]); + tToolNBT.setLong("Voltage", aElectricArray[1]); + tToolNBT.setLong("Tier", aElectricArray[2]); + tToolNBT.setLong("SpecialData", aElectricArray[3]); + } + + tMainNBT.setTag("GT.ToolStats", tToolNBT); + rStack.setTagCompound(tMainNBT); + } + isItemStackUsable(rStack); + return rStack; + } + + /** + * Called by the Block Harvesting Event within the GT_Proxy + */ + @Mod.EventHandler + public void onHarvestBlockEvent(ArrayList<ItemStack> aDrops, ItemStack aStack, EntityPlayer aPlayer, Block aBlock, + int aX, int aY, int aZ, byte aMetaData, int aFortune, boolean aSilkTouch, BlockEvent.HarvestDropsEvent aEvent) { + IToolStats tStats = getToolStats(aStack); + if (isItemStackUsable(aStack) && getDigSpeed(aStack, aBlock, aMetaData) > 0.0F) doDamage( + aStack, + (long) tStats + .convertBlockDrops(aDrops, aStack, aPlayer, aBlock, aX, aY, aZ, aMetaData, aFortune, aSilkTouch, aEvent) + * tStats.getToolDamagePerDropConversion()); + } + + @Mod.EventHandler + public float onBlockBreakSpeedEvent(float aDefault, ItemStack aStack, EntityPlayer aPlayer, Block aBlock, int aX, + int aY, int aZ, byte aMetaData, PlayerEvent.BreakSpeed aEvent) { + IToolStats tStats = getToolStats(aStack); + return tStats == null ? aDefault + : tStats.getMiningSpeed(aBlock, aMetaData, aDefault, aPlayer, aPlayer.worldObj, aX, aY, aZ); + } + + @Override + public boolean onBlockStartBreak(ItemStack aStack, int aX, int aY, int aZ, EntityPlayer aPlayer) { + if (aPlayer.worldObj.isRemote) { + return false; + } + IToolStats tStats = getToolStats(aStack); + Block aBlock = aPlayer.worldObj.getBlock(aX, aY, aZ); + if (tStats.isChainsaw() && (aBlock instanceof IShearable target)) { + if ((target.isShearable(aStack, aPlayer.worldObj, aX, aY, aZ))) { + ArrayList<ItemStack> drops = target.onSheared( + aStack, + aPlayer.worldObj, + aX, + aY, + aZ, + EnchantmentHelper.getEnchantmentLevel(Enchantment.fortune.effectId, aStack)); + for (ItemStack stack : drops) { + float f = 0.7F; + double d = itemRand.nextFloat() * f + (1.0F - f) * 0.5D; + double d1 = itemRand.nextFloat() * f + (1.0F - f) * 0.5D; + double d2 = itemRand.nextFloat() * f + (1.0F - f) * 0.5D; + EntityItem entityitem = new EntityItem(aPlayer.worldObj, aX + d, aY + d1, aZ + d2, stack); + entityitem.delayBeforeCanPickup = 10; + aPlayer.worldObj.spawnEntityInWorld(entityitem); + } + aPlayer.addStat(net.minecraft.stats.StatList.mineBlockStatArray[Block.getIdFromBlock(aBlock)], 1); + onBlockDestroyed(aStack, aPlayer.worldObj, aBlock, aX, aY, aZ, aPlayer); + } + return false; + } + return super.onBlockStartBreak(aStack, aX, aY, aZ, aPlayer); + } + + @Override + public boolean onLeftClickEntity(ItemStack aStack, EntityPlayer aPlayer, Entity aEntity) { + IToolStats tStats = getToolStats(aStack); + if (tStats == null || !isItemStackUsable(aStack)) return true; + GT_Utility.doSoundAtClient(tStats.getEntityHitSound(), 1, 1.0F); + if (super.onLeftClickEntity(aStack, aPlayer, aEntity)) return true; + if (aEntity.canAttackWithItem() && !aEntity.hitByEntity(aPlayer)) { + float tMagicDamage = tStats.getMagicDamageAgainstEntity( + aEntity instanceof EntityLivingBase + ? EnchantmentHelper.getEnchantmentModifierLiving(aPlayer, (EntityLivingBase) aEntity) + : 0.0F, + aEntity, + aStack, + aPlayer), + tDamage = tStats.getNormalDamageAgainstEntity( + (float) aPlayer.getEntityAttribute(SharedMonsterAttributes.attackDamage) + .getAttributeValue() + getToolCombatDamage(aStack), + aEntity, + aStack, + aPlayer); + if (tDamage + tMagicDamage > 0.0F) { + boolean tCriticalHit = aPlayer.fallDistance > 0.0F && !aPlayer.onGround + && !aPlayer.isOnLadder() + && !aPlayer.isInWater() + && !aPlayer.isPotionActive(Potion.blindness) + && aPlayer.ridingEntity == null + && aEntity instanceof EntityLivingBase; + if (tCriticalHit && tDamage > 0.0F) tDamage *= 1.5F; + tDamage += tMagicDamage; + if (aEntity.attackEntityFrom(tStats.getDamageSource(aPlayer, aEntity), tDamage)) { + if (aEntity instanceof EntityLivingBase) + aEntity.setFire(EnchantmentHelper.getFireAspectModifier(aPlayer) * 4); + int tKnockcack = (aPlayer.isSprinting() ? 1 : 0) + (aEntity instanceof EntityLivingBase + ? EnchantmentHelper.getKnockbackModifier(aPlayer, (EntityLivingBase) aEntity) + : 0); + if (tKnockcack > 0) { + aEntity.addVelocity( + -MathHelper.sin(aPlayer.rotationYaw * (float) Math.PI / 180.0F) * tKnockcack * 0.5F, + 0.1D, + MathHelper.cos(aPlayer.rotationYaw * (float) Math.PI / 180.0F) * tKnockcack * 0.5F); + aPlayer.motionX *= 0.6D; + aPlayer.motionZ *= 0.6D; + aPlayer.setSprinting(false); + } + if (tCriticalHit) aPlayer.onCriticalHit(aEntity); + if (tMagicDamage > 0.0F) aPlayer.onEnchantmentCritical(aEntity); + if (tDamage >= 18.0F) aPlayer.triggerAchievement(AchievementList.overkill); + aPlayer.setLastAttacker(aEntity); + if (aEntity instanceof EntityLivingBase) + EnchantmentHelper.func_151384_a((EntityLivingBase) aEntity, aPlayer); + EnchantmentHelper.func_151385_b(aPlayer, aEntity); + if (aEntity instanceof EntityLivingBase) + aPlayer.addStat(StatList.damageDealtStat, Math.round(tDamage * 10.0F)); + aEntity.hurtResistantTime = Math + .max(1, tStats.getHurtResistanceTime(aEntity.hurtResistantTime, aEntity)); + aPlayer.addExhaustion(0.3F); + doDamage(aStack, tStats.getToolDamagePerEntityAttack()); + } + } + } + if (aStack.stackSize <= 0) aPlayer.destroyCurrentEquippedItem(); + return true; + } + + @Override + public ItemStack onItemRightClick(ItemStack aStack, World aWorld, EntityPlayer aPlayer) { + IToolStats tStats = getToolStats(aStack); + if (tStats != null && tStats.canBlock()) aPlayer.setItemInUse(aStack, 72000); + return super.onItemRightClick(aStack, aWorld, aPlayer); + } + + @Override + public final int getMaxItemUseDuration(ItemStack aStack) { + return 72000; + } + + @Override + public final EnumAction getItemUseAction(ItemStack aStack) { + IToolStats tStats = getToolStats(aStack); + if (tStats != null && tStats.canBlock()) return EnumAction.block; + return EnumAction.none; + } + + @Override + @SideOnly(Side.CLIENT) + public final void getSubItems(Item aItem, CreativeTabs aCreativeTab, List<ItemStack> aList) { + for (int i = 0; i < 32766; i += 2) { + if (getToolStats(new ItemStack(this, 1, i)) != null) { + ItemStack tStack = new ItemStack(this, 1, i); + isItemStackUsable(tStack); + aList.add(tStack); + aList.add(getToolWithStats(i, 1, Materials.Neutronium, Materials.Neutronium, null)); + } + } + } + + @Override + @SideOnly(Side.CLIENT) + public final void registerIcons(IIconRegister aIconRegister) { + // + } + + @Override + public final IIcon getIconFromDamage(int aMetaData) { + return null; + } + + @Override + public void addAdditionalToolTips(List<String> aList, ItemStack aStack, EntityPlayer aPlayer) { + long tMaxDamage = getToolMaxDamage(aStack); + Materials tMaterial = getPrimaryMaterial(aStack); + IToolStats tStats = getToolStats(aStack); + int tOffset = getElectricStats(aStack) != null ? 2 : 1; + if (tStats != null) { + if (tStats instanceof GT_Tool_Turbine) { + + // Durability -> toolMaxDamage + // % Efficiency -> toolCombatDamage -> toolQuality + // Optimal Flow -> toolSpeed + // EU/t -> toolCombatDamage, toolSpeed + // Overflow Tier -> toolQuality + float aBaseEff = (5f + getToolCombatDamage(aStack)) * 1000f; + + // It was noted by IntelliJ that replacing ((GT_MetaGenerated_Tool) aStack.getItem()) with + // GT_MetaGenerated_Tool can have side effects. This refactoring will need tests. + @SuppressWarnings("AccessStaticViaInstance") + float aOptFlow = (Math.max( + Float.MIN_NORMAL, + ((GT_MetaGenerated_Tool) aStack.getItem()).getToolStats(aStack) + .getSpeedMultiplier() + * ((GT_MetaGenerated_Tool) aStack.getItem()).getPrimaryMaterial(aStack).mToolSpeed + * 50F)); + aList.add( + tOffset + 0, + EnumChatFormatting.GRAY + String.format( + transItem("001", "Durability: %s/%s"), + "" + EnumChatFormatting.GREEN + formatNumbers(tMaxDamage - getToolDamage(aStack)) + " ", + " " + formatNumbers(tMaxDamage)) + EnumChatFormatting.GRAY); + aList.add( + tOffset + 1, + EnumChatFormatting.GRAY + String.format( + transItem("002", "%s lvl %s"), + tMaterial.mLocalizedName + EnumChatFormatting.YELLOW, + "" + getHarvestLevel(aStack, "")) + EnumChatFormatting.GRAY); + aList.add( + tOffset + 2, + EnumChatFormatting.WHITE + + String.format( + transItem("005", "Turbine Efficiency: %s"), + "" + EnumChatFormatting.BLUE + (50.0F + (10.0F * getToolCombatDamage(aStack)))) + + "%" + + EnumChatFormatting.GRAY); + aList.add( + tOffset + 3, + EnumChatFormatting.WHITE + String.format( + transItem("006", "Optimal Steam flow: %s L/t"), + "" + EnumChatFormatting.GOLD + + formatNumbers( + GT_Utility.safeInt( + (long) (Math.max( + Float.MIN_NORMAL, + tStats.getSpeedMultiplier() * getPrimaryMaterial(aStack).mToolSpeed + * (1000 * getPrimaryMaterial(aStack).mSteamMultiplier / 20))))) + + EnumChatFormatting.GRAY)); + aList.add( + tOffset + 4, + EnumChatFormatting.WHITE + String.format( + transItem("900", "Energy from Optimal Steam Flow: %s EU/t"), + "" + EnumChatFormatting.GOLD + + formatNumbers( + GT_Utility.safeInt( + (long) (Math.max( + Float.MIN_NORMAL, + tStats.getSpeedMultiplier() * getPrimaryMaterial(aStack).mToolSpeed + * (1000 * getPrimaryMaterial(aStack).mSteamMultiplier / 20)) + * (50.0F + (10.0F * getToolCombatDamage(aStack))) + / 200))) + + EnumChatFormatting.GRAY)); + { + float[] calculatedFlow = calculateLooseFlow(aOptFlow, aBaseEff); + float aOptFlowLoose = calculatedFlow[0]; + float aBaseEffLoose = calculatedFlow[1]; + + aList.add( + tOffset + 5, + EnumChatFormatting.AQUA + String.format( + transItem("500", "Turbine Efficiency (Loose): %s"), + "" + EnumChatFormatting.BLUE + (long) aBaseEffLoose / 100 + "%" + EnumChatFormatting.GRAY)); + aList.add( + tOffset + 6, + EnumChatFormatting.AQUA + String.format( + transItem("501", "Optimal Steam flow (Loose): %s L/t"), + "" + EnumChatFormatting.GOLD + + formatNumbers(((long) aOptFlowLoose * getPrimaryMaterial(aStack).mSteamMultiplier)) + + EnumChatFormatting.GRAY)); + aList.add( + tOffset + 7, + EnumChatFormatting.AQUA + String.format( + transItem("901", "Energy from Optimal Steam Flow (Loose): %s EU/t"), + "" + EnumChatFormatting.GOLD + + formatNumbers( + ((long) aOptFlowLoose * getPrimaryMaterial(aStack).mSteamMultiplier / 10000) + * ((long) aBaseEffLoose / 2)) + + EnumChatFormatting.GRAY)); + aList.add( + tOffset + 8, + EnumChatFormatting.GRAY + "(Superheated Steam EU values are 2x those of Steam)"); + } + aList.add( + tOffset + 9, + EnumChatFormatting.WHITE + String.format( + transItem("902", "Optimal SC Steam flow: %s L/t"), + "" + EnumChatFormatting.GOLD + + formatNumbers( + GT_Utility.safeInt( + (long) (Math.max( + Float.MIN_NORMAL, + tStats.getSpeedMultiplier() * getPrimaryMaterial(aStack).mToolSpeed + * (1000f / 20f))))) + + EnumChatFormatting.GRAY)); + aList.add( + tOffset + 10, + EnumChatFormatting.WHITE + String.format( + transItem("903", "Energy from Optimal SC Steam Flow: %s EU/t"), + "" + EnumChatFormatting.GOLD + + formatNumbers( + GT_Utility.safeInt( + (long) (Math.max( + Float.MIN_NORMAL, + tStats.getSpeedMultiplier() * getPrimaryMaterial(aStack).mToolSpeed + * (1000f / 20f)) + * (50.0F + (10.0F * getToolCombatDamage(aStack)))))) + + EnumChatFormatting.GRAY)); + aList.add( + tOffset + 11, + EnumChatFormatting.LIGHT_PURPLE + String.format( + transItem("007", "Energy from Optimal Gas Flow: %s EU/t"), + "" + EnumChatFormatting.GOLD + + formatNumbers( + GT_Utility.safeInt( + (long) (Math.max( + Float.MIN_NORMAL, + tStats.getSpeedMultiplier() * getPrimaryMaterial(aStack).mToolSpeed + * 50 + * getPrimaryMaterial(aStack).mGasMultiplier) + * (50.0F + (10.0F * getToolCombatDamage(aStack))) + / 100))) + + EnumChatFormatting.GRAY)); + aList.add( + tOffset + 12, + EnumChatFormatting.LIGHT_PURPLE + String.format( + transItem("008", "Energy from Optimal Plasma Flow: %s EU/t"), + "" + EnumChatFormatting.GOLD + + formatNumbers( + GT_Utility.safeInt( + (long) (Math.max( + Float.MIN_NORMAL, + tStats.getSpeedMultiplier() * getPrimaryMaterial(aStack).mToolSpeed + * 2000 + * getPrimaryMaterial(aStack).mPlasmaMultiplier) + * (50.0F + (10.0F * getToolCombatDamage(aStack))) + * (1.05 / 100)))) + + EnumChatFormatting.GRAY)); + aList.add( + tOffset + 14, + EnumChatFormatting.GRAY + "(EU/t values include efficiency and are not 100% accurate)"); + int toolQualityLevel = GT_MetaGenerated_Tool.getPrimaryMaterial(aStack).mToolQuality; + int overflowMultiplier = 0; + if (toolQualityLevel >= 6) { + overflowMultiplier = 3; + } else if (toolQualityLevel >= 3) { + overflowMultiplier = 2; + } else { + overflowMultiplier = 1; + } + aList.add( + tOffset + 13, + EnumChatFormatting.LIGHT_PURPLE + String.format( + transItem("502", "Overflow Efficiency Tier: %s"), + "" + EnumChatFormatting.GOLD + overflowMultiplier + EnumChatFormatting.GRAY)); + + } else { + aList.add( + tOffset, + EnumChatFormatting.WHITE + String.format( + transItem("001", "Durability: %s/%s"), + "" + EnumChatFormatting.GREEN + formatNumbers(tMaxDamage - getToolDamage(aStack)) + " ", + " " + formatNumbers(tMaxDamage)) + EnumChatFormatting.GRAY); + aList.add( + tOffset + 1, + EnumChatFormatting.WHITE + String.format( + transItem("002", "%s lvl %s"), + tMaterial.mLocalizedName + EnumChatFormatting.YELLOW, + "" + getHarvestLevel(aStack, "")) + EnumChatFormatting.GRAY); + aList.add( + tOffset + 2, + EnumChatFormatting.WHITE + String.format( + transItem("003", "Attack Damage: %s"), + "" + EnumChatFormatting.BLUE + getToolCombatDamage(aStack)) + EnumChatFormatting.GRAY); + aList.add( + tOffset + 3, + EnumChatFormatting.WHITE + + String.format( + transItem("004", "Mining Speed: %s"), + "" + EnumChatFormatting.GOLD + + Math.max( + Float.MIN_NORMAL, + tStats.getSpeedMultiplier() * getPrimaryMaterial(aStack).mToolSpeed)) + + EnumChatFormatting.GRAY); + NBTTagCompound aNBT = aStack.getTagCompound(); + if (aNBT != null) { + aNBT = aNBT.getCompoundTag("GT.ToolStats"); + if (aNBT != null && aNBT.hasKey("Heat")) { + int tHeat = aNBT.getInteger("Heat"); + long tWorldTime = aPlayer.getEntityWorld() + .getWorldTime(); + if (aNBT.hasKey("HeatTime")) { + long tHeatTime = aNBT.getLong("HeatTime"); + if (tWorldTime > (tHeatTime + 10)) { + tHeat = (int) (tHeat - ((tWorldTime - tHeatTime) / 10)); + if (tHeat < 300 && tHeat > -10000) tHeat = 300; + } + aNBT.setLong("HeatTime", tWorldTime); + if (tHeat > -10000) aNBT.setInteger("Heat", tHeat); + } + + aList.add( + tOffset + 3, + EnumChatFormatting.RED + "Heat: " + + aNBT.getInteger("Heat") + + " K" + + EnumChatFormatting.GRAY); + } + } + } + } + } + + @Override + public Long[] getFluidContainerStats(ItemStack aStack) { + return null; + } + + @Override + public Long[] getElectricStats(ItemStack aStack) { + NBTTagCompound aNBT = aStack.getTagCompound(); + if (aNBT != null) { + aNBT = aNBT.getCompoundTag("GT.ToolStats"); + if (aNBT != null && aNBT.getBoolean("Electric")) return new Long[] { aNBT.getLong("MaxCharge"), + aNBT.getLong("Voltage"), aNBT.getLong("Tier"), aNBT.getLong("SpecialData") }; + } + return null; + } + + public float getToolCombatDamage(ItemStack aStack) { + IToolStats tStats = getToolStats(aStack); + if (tStats == null) return 0; + return tStats.getBaseDamage() + getPrimaryMaterial(aStack).mToolQuality; + } + + @Override + public final boolean doDamageToItem(ItemStack aStack, int aVanillaDamage) { + return doDamage(aStack, aVanillaDamage * 100L); + } + + public final boolean doDamage(ItemStack aStack, long aAmount) { + if (!isItemStackUsable(aStack)) return false; + Long[] tElectric = getElectricStats(aStack); + if (tElectric == null) { + long tNewDamage = getToolDamage(aStack) + aAmount; + setToolDamage(aStack, tNewDamage); + if (tNewDamage >= getToolMaxDamage(aStack)) { + IToolStats tStats = getToolStats(aStack); + if (tStats == null || GT_Utility.setStack(aStack, tStats.getBrokenItem(aStack)) == null) { + if (tStats != null) GT_Utility.doSoundAtClient(tStats.getBreakingSound(), 1, 1.0F); + if (aStack.stackSize > 0) aStack.stackSize--; + } + } + return true; + } + if (use(aStack, (int) aAmount, null)) { + if (java.util.concurrent.ThreadLocalRandom.current() + .nextInt(0, 25) == 0) { + long tNewDamage = getToolDamage(aStack) + aAmount; + setToolDamage(aStack, tNewDamage); + if (tNewDamage >= getToolMaxDamage(aStack)) { + IToolStats tStats = getToolStats(aStack); + if (tStats == null || GT_Utility.setStack(aStack, tStats.getBrokenItem(aStack)) == null) { + if (tStats != null) GT_Utility.doSoundAtClient(tStats.getBreakingSound(), 1, 1.0F); + if (aStack.stackSize > 0) aStack.stackSize--; + } + } + } + return true; + } + return false; + } + + @Override + public float getDigSpeed(ItemStack aStack, Block aBlock, int aMetaData) { + if (!isItemStackUsable(aStack)) return 0.0F; + IToolStats tStats = getToolStats(aStack); + if (tStats == null || Math.max(0, getHarvestLevel(aStack, "")) < aBlock.getHarvestLevel(aMetaData)) return 0.0F; + return tStats.isMinableBlock(aBlock, (byte) aMetaData) + ? Math.max(Float.MIN_NORMAL, tStats.getSpeedMultiplier() * getPrimaryMaterial(aStack).mToolSpeed) + : 0.0F; + } + + @Override + public final boolean canHarvestBlock(Block aBlock, ItemStack aStack) { + return getDigSpeed(aStack, aBlock, (byte) 0) > 0.0F; + } + + @Override + public final int getHarvestLevel(ItemStack aStack, String aToolClass) { + IToolStats tStats = getToolStats(aStack); + return tStats == null ? -1 : tStats.getBaseQuality() + getPrimaryMaterial(aStack).mToolQuality; + } + + @Override + public boolean onBlockDestroyed(ItemStack aStack, World aWorld, Block aBlock, int aX, int aY, int aZ, + EntityLivingBase aPlayer) { + if (!isItemStackUsable(aStack)) return false; + IToolStats tStats = getToolStats(aStack); + if (tStats == null) return false; + GT_Utility.doSoundAtClient(tStats.getMiningSound(), 1, 1.0F); + doDamage( + aStack, + (int) Math.max(1, aBlock.getBlockHardness(aWorld, aX, aY, aZ) * tStats.getToolDamagePerBlockBreak())); + return getDigSpeed(aStack, aBlock, aWorld.getBlockMetadata(aX, aY, aZ)) > 0.0F; + } + + @Override + public final ItemStack getContainerItem(ItemStack aStack) { + return getContainerItem(aStack, true); + } + + @Override + public final boolean hasContainerItem(ItemStack aStack) { + return getContainerItem(aStack, false) != null; + } + + private ItemStack getContainerItem(ItemStack aStack, boolean playSound) { + if (!isItemStackUsable(aStack)) return null; + aStack = GT_Utility.copyAmount(1, aStack); + IToolStats tStats = getToolStats(aStack); + if (tStats == null) return null; + doDamage(aStack, tStats.getToolDamagePerContainerCraft()); + aStack = aStack.stackSize > 0 ? aStack : null; + if (playSound && GT_Mod.gregtechproxy.mTicksUntilNextCraftSound <= 0) { + GT_Mod.gregtechproxy.mTicksUntilNextCraftSound = 10; + String sound = (aStack == null) ? tStats.getBreakingSound() : tStats.getCraftingSound(); + GT_Utility.doSoundAtClient(sound, 1, 1.0F); + } + return aStack; + } + + public IToolStats getToolStats(ItemStack aStack) { + isItemStackUsable(aStack); + return getToolStatsInternal(aStack); + } + + public byte getToolMaxMode(ItemStack aStack) { + IToolStats stats = getToolStats(aStack); + if (stats != null) { + return stats.getMaxMode(); + } + return 1; + } + + private IToolStats getToolStatsInternal(ItemStack aStack) { + return aStack == null ? null : mToolStats.get((short) aStack.getItemDamage()); + } + + @Override + public float getSaplingModifier(ItemStack aStack, World aWorld, EntityPlayer aPlayer, int aX, int aY, int aZ) { + IToolStats tStats = getToolStats(aStack); + return tStats != null && tStats.isGrafter() ? Math.min(100.0F, (1 + getHarvestLevel(aStack, "")) * 20.0F) + : 0.0F; + } + + @Override + public boolean canWhack(EntityPlayer aPlayer, ItemStack aStack, int aX, int aY, int aZ) { + if (!isItemStackUsable(aStack)) return false; + IToolStats tStats = getToolStats(aStack); + return tStats != null && tStats.isCrowbar(); + } + + @Override + public void onWhack(EntityPlayer aPlayer, ItemStack aStack, int aX, int aY, int aZ) { + IToolStats tStats = getToolStats(aStack); + if (tStats != null) doDamage(aStack, tStats.getToolDamagePerEntityAttack()); + } + + @Override + public boolean canWrench(EntityPlayer player, int x, int y, int z) { + if (player == null) return false; + return canWrench(player.getHeldItem(), player, x, y, z); + } + + @Override + public boolean canWrench(ItemStack wrench, EntityPlayer player, int x, int y, int z) { + if (wrench == null) return false; + if (!isItemStackUsable(wrench)) return false; + IToolStats tStats = getToolStats(player.getCurrentEquippedItem()); + return tStats != null && tStats.isWrench(); + } + + @Override + public void wrenchUsed(EntityPlayer player, int x, int y, int z) { + if (player == null) return; + if (player.getCurrentEquippedItem() == null) return; + IToolStats tStats = getToolStats(player.getCurrentEquippedItem()); + if (tStats != null) doDamage(player.getCurrentEquippedItem(), tStats.getToolDamagePerEntityAttack()); + } + + @Override + public boolean canUse(ItemStack stack, EntityPlayer player, int x, int y, int z) { + return canWrench(player, x, y, z); + } + + // ProjectRed screwdriver + @Override + public boolean canUse(EntityPlayer player, ItemStack stack) { + if (player == null) return false; + if (GT_Utility.isStackInvalid(stack) || !isItemStackUsable(stack)) return false; + IToolStats tStats = getToolStats(stack); + return tStats != null && tStats.isScrewdriver(); + } + + @Override + public void damageScrewdriver(EntityPlayer player, ItemStack stack) { + if (player == null) return; + if (GT_Utility.isStackInvalid(stack) || !isItemStackUsable(stack)) return; + IToolStats tStats = getToolStats(stack); + if (tStats != null) doDamage(stack, tStats.getToolDamagePerEntityAttack()); + } + + @Override + public void used(ItemStack stack, EntityPlayer player, int x, int y, int z) { + wrenchUsed(player, x, y, z); + } + + @Override + public boolean shouldHideFacades(ItemStack stack, EntityPlayer player) { + if (player == null) return false; + if (player.getCurrentEquippedItem() == null) return false; + if (!isItemStackUsable(player.getCurrentEquippedItem())) return false; + IToolStats tStats = getToolStats(player.getCurrentEquippedItem()); + return tStats.isWrench(); + } + + @Override + public boolean canLink(EntityPlayer aPlayer, ItemStack aStack, EntityMinecart cart) { + if (!isItemStackUsable(aStack)) return false; + IToolStats tStats = getToolStats(aStack); + return tStats != null && tStats.isCrowbar(); + } + + @Override + public void onLink(EntityPlayer aPlayer, ItemStack aStack, EntityMinecart cart) { + IToolStats tStats = getToolStats(aStack); + if (tStats != null) doDamage(aStack, tStats.getToolDamagePerEntityAttack()); + } + + @Override + public boolean canBoost(EntityPlayer aPlayer, ItemStack aStack, EntityMinecart cart) { + if (!isItemStackUsable(aStack)) return false; + IToolStats tStats = getToolStats(aStack); + return tStats != null && tStats.isCrowbar(); + } + + @Override + public void onBoost(EntityPlayer aPlayer, ItemStack aStack, EntityMinecart cart) { + IToolStats tStats = getToolStats(aStack); + if (tStats != null) doDamage(aStack, tStats.getToolDamagePerEntityAttack()); + } + + @Override + public void onCreated(ItemStack aStack, World aWorld, EntityPlayer aPlayer) { + IToolStats tStats = getToolStats(aStack); + if (tStats != null && aPlayer != null) tStats.onToolCrafted(aStack, aPlayer); + super.onCreated(aStack, aWorld, aPlayer); + } + + @Override + public final boolean doesContainerItemLeaveCraftingGrid(ItemStack aStack) { + return false; + } + + @Override + public final int getItemStackLimit(ItemStack aStack) { + return 1; + } + + @Override + public boolean isFull3D() { + return true; + } + + @Override + public boolean isItemStackUsable(ItemStack aStack) { + IToolStats tStats = getToolStatsInternal(aStack); + if (aStack.getItemDamage() % 2 != 0 || tStats == null) { + NBTTagCompound aNBT = aStack.getTagCompound(); + if (aNBT != null) aNBT.removeTag("ench"); + return false; + } + Materials aMaterial = getPrimaryMaterial(aStack); + HashMap<Integer, Integer> tMap = new HashMap<>(), tResult = new HashMap<>(); + if (aMaterial.mEnchantmentTools != null) { + tMap.put(aMaterial.mEnchantmentTools.effectId, (int) aMaterial.mEnchantmentToolsLevel); + if (aMaterial.mEnchantmentTools == Enchantment.fortune) + tMap.put(Enchantment.looting.effectId, (int) aMaterial.mEnchantmentToolsLevel); + if (aMaterial.mEnchantmentTools == Enchantment.knockback) + tMap.put(Enchantment.power.effectId, (int) aMaterial.mEnchantmentToolsLevel); + if (aMaterial.mEnchantmentTools == Enchantment.fireAspect) + tMap.put(Enchantment.flame.effectId, (int) aMaterial.mEnchantmentToolsLevel); + } + Enchantment[] tEnchants = tStats.getEnchantments(aStack); + int[] tLevels = tStats.getEnchantmentLevels(aStack); + for (int i = 0; i < tEnchants.length; i++) if (tLevels[i] > 0) { + Integer tLevel = tMap.get(tEnchants[i].effectId); + tMap.put( + tEnchants[i].effectId, + tLevel == null ? tLevels[i] : tLevel == tLevels[i] ? tLevel + 1 : Math.max(tLevel, tLevels[i])); + } + for (Entry<Integer, Integer> tEntry : tMap.entrySet()) { + if (tEntry.getKey() == 33 || (tEntry.getKey() == 20 && tEntry.getValue() > 2) + || tEntry.getKey() == Enchantment_Radioactivity.INSTANCE.effectId) + tResult.put(tEntry.getKey(), tEntry.getValue()); + else switch (Enchantment.enchantmentsList[tEntry.getKey()].type) { + case weapon: + if (tStats.isWeapon()) tResult.put(tEntry.getKey(), tEntry.getValue()); + break; + case all: + tResult.put(tEntry.getKey(), tEntry.getValue()); + break; + case armor: + case armor_feet: + case armor_head: + case armor_legs: + case armor_torso: + break; + case bow: + if (tStats.isRangedWeapon()) tResult.put(tEntry.getKey(), tEntry.getValue()); + break; + case breakable: + break; + case fishing_rod: + break; + case digger: + if (tStats.isMiningTool()) tResult.put(tEntry.getKey(), tEntry.getValue()); + break; + } + } + EnchantmentHelper.setEnchantments(tResult, aStack); + return true; + } + + @Override + public String getItemStackDisplayName(ItemStack aStack) { + + String result = super.getItemStackDisplayName(aStack); + IToolStats toolStats = getToolStats(aStack); + if (toolStats != null) { + String toolName = toolStats.getToolTypeName(); + if (toolName == null) return result; + + String key = "gt." + toolName + ".mode." + getToolMode(aStack); + if (StatCollector.canTranslate(key)) { + result += " (" + StatCollector.translateToLocal(key) + ")"; + } + } + return result; + + } + + @Override + public short getChargedMetaData(ItemStack aStack) { + return (short) (aStack.getItemDamage() - (aStack.getItemDamage() % 2)); + } + + @Override + public short getEmptyMetaData(ItemStack aStack) { + NBTTagCompound aNBT = aStack.getTagCompound(); + if (aNBT != null) aNBT.removeTag("ench"); + return (short) (aStack.getItemDamage() + 1 - (aStack.getItemDamage() % 2)); + } + + @Override + public int getItemEnchantability() { + return 0; + } + + @Override + public boolean isBookEnchantable(ItemStack aStack, ItemStack aBook) { + return false; + } + + @Override + public boolean getIsRepairable(ItemStack aStack, ItemStack aMaterial) { + return false; + } +} diff --git a/src/main/java/gregtech/api/items/GT_RadioactiveCellIC_Item.java b/src/main/java/gregtech/api/items/GT_RadioactiveCellIC_Item.java new file mode 100644 index 0000000000..2509cf6261 --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_RadioactiveCellIC_Item.java @@ -0,0 +1,219 @@ +package gregtech.api.items; + +import java.util.ArrayList; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +import gregtech.api.enums.GT_Values; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.util.GT_Utility; +import ic2.api.reactor.IReactor; +import ic2.api.reactor.IReactorComponent; +import ic2.core.IC2Potion; +import ic2.core.init.MainConfig; +import ic2.core.util.ConfigUtil; + +public class GT_RadioactiveCellIC_Item extends GT_RadioactiveCell_Item implements IReactorComponent { + + private static final int MYSTERIOUS_MULTIPLIER_HEAT = 4; + public final int numberOfCells; + public final float sEnergy; + public final int sRadiation; + public final float sHeat; + public final ItemStack sDepleted; + public final boolean sMox; + + public GT_RadioactiveCellIC_Item(String aUnlocalized, String aEnglish, int aCellcount, int maxDamage, float aEnergy, + int aRadiation, float aHeat, ItemStack aDepleted, boolean aMox) { + super(aUnlocalized, aEnglish, aCellcount); + setMaxStackSize(64); + this.maxDmg = maxDamage; + this.numberOfCells = aCellcount; + this.sEnergy = aEnergy; + this.sRadiation = aRadiation; + this.sHeat = aHeat; + this.sDepleted = aDepleted; + this.sMox = aMox; + if (aDepleted != null && aEnergy > 0 && aHeat > 0) { + // avoid adding depleted cells to recipe map + + int pulses = aCellcount / 2 + 1; + + // for the mysterious constant 5.0f, + // see ic2.core.block.reactor.tileentity.TileEntityNuclearReactorElectric.getOfferedEnergy + // don't ask, just accept + float nukePowerMult = 5.0f * ConfigUtil.getFloat(MainConfig.get(), "balance/energy/generator/nuclear"); + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(this)) + .itemOutputs(aDepleted) + .setNEIDesc( + aMox ? "MOX Model" : "Uranium Model", + "Neutron Pulse: " + aCellcount, + aCellcount == 1 + ? String.format("Heat: %.1f * n1 * (n1 + 1)", (aHeat * MYSTERIOUS_MULTIPLIER_HEAT) / 2f) + : String.format( + "Heat: %.1f * (%d + n1) * (%d + n1)", + (aHeat * MYSTERIOUS_MULTIPLIER_HEAT) * aCellcount / 2f, + aCellcount, + aCellcount + 1), + String.format( + "Energy: %.1f + n2 * %.1f EU/t", + aEnergy * aCellcount * pulses * nukePowerMult, + aEnergy * nukePowerMult)) + .duration(0) + .eut(0) + .addTo(RecipeMaps.ic2NuclearFakeRecipes); + } + } + + private static int checkPulseable(IReactor reactor, int x, int y, ItemStack me, int mex, int mey, boolean heatrun) { + ItemStack other = reactor.getItemAt(x, y); + if ((other != null) && ((other.getItem() instanceof IReactorComponent)) + && (((IReactorComponent) other.getItem()) + .acceptUraniumPulse(reactor, other, me, x, y, mex, mey, heatrun))) { + return 1; + } + return 0; + } + + @Override + public void processChamber(IReactor reactor, ItemStack yourStack, int x, int y, boolean heatrun) { + if (!reactor.produceEnergy()) { + return; + } + for (int iteration = 0; iteration < this.numberOfCells; iteration++) { + int pulses = 1 + this.numberOfCells / 2; + if (!heatrun) { + for (int i = 0; i < pulses; i++) { + acceptUraniumPulse(reactor, yourStack, yourStack, x, y, x, y, heatrun); + } + checkPulseable(reactor, x - 1, y, yourStack, x, y, heatrun); + checkPulseable(reactor, x + 1, y, yourStack, x, y, heatrun); + checkPulseable(reactor, x, y - 1, yourStack, x, y, heatrun); + checkPulseable(reactor, x, y + 1, yourStack, x, y, heatrun); + } else { + pulses += checkPulseable(reactor, x - 1, y, yourStack, x, y, heatrun) + + checkPulseable(reactor, x + 1, y, yourStack, x, y, heatrun) + + checkPulseable(reactor, x, y - 1, yourStack, x, y, heatrun) + + checkPulseable(reactor, x, y + 1, yourStack, x, y, heatrun); + + // int heat = sumUp(pulses) * 4; + + int heat = triangularNumber(pulses) * MYSTERIOUS_MULTIPLIER_HEAT; + + heat = getFinalHeat(reactor, yourStack, x, y, heat); + + ArrayList<ItemStackCoord> heatAcceptors = new ArrayList<>(); + checkHeatAcceptor(reactor, x - 1, y, heatAcceptors); + checkHeatAcceptor(reactor, x + 1, y, heatAcceptors); + checkHeatAcceptor(reactor, x, y - 1, heatAcceptors); + checkHeatAcceptor(reactor, x, y + 1, heatAcceptors); + heat = Math.round(heat * sHeat); + while ((heatAcceptors.size() > 0) && (heat > 0)) { + + int dheat = heat / heatAcceptors.size(); + heat -= dheat; + dheat = ((IReactorComponent) heatAcceptors.get(0).stack.getItem()).alterHeat( + reactor, + heatAcceptors.get(0).stack, + heatAcceptors.get(0).x, + heatAcceptors.get(0).y, + dheat); + heat += dheat; + heatAcceptors.remove(0); + } + if (heat > 0) { + reactor.addHeat(heat); + } + } + } + if (getDamageOfStack(yourStack) >= getMaxDamageEx() - 1) { + reactor.setItemAt(x, y, sDepleted.copy()); + } else if (heatrun) { + damageItemStack(yourStack, 1); + } + } + + protected int getFinalHeat(IReactor reactor, ItemStack stack, int x, int y, int heat) { + if (sMox && reactor.isFluidCooled()) { + float breedereffectiveness = (float) reactor.getHeat() / (float) reactor.getMaxHeat(); + if (breedereffectiveness > 0.5D) { + heat *= 2; + } + } + return heat; + } + + private void checkHeatAcceptor(IReactor reactor, int x, int y, ArrayList<ItemStackCoord> heatAcceptors) { + ItemStack thing = reactor.getItemAt(x, y); + if ((thing != null) && ((thing.getItem() instanceof IReactorComponent)) + && (((IReactorComponent) thing.getItem()).canStoreHeat(reactor, thing, x, y))) { + heatAcceptors.add(new ItemStackCoord(thing, x, y)); + } + } + + @Override + public boolean acceptUraniumPulse(IReactor reactor, ItemStack yourStack, ItemStack pulsingStack, int youX, int youY, + int pulseX, int pulseY, boolean heatrun) { + if (!heatrun) { + if (sMox) { + float breedereffectiveness = (float) reactor.getHeat() / (float) reactor.getMaxHeat(); + float ReaktorOutput = 1.5F * breedereffectiveness + 1.0F; + reactor.addOutput(ReaktorOutput * this.sEnergy); + } else { + reactor.addOutput(1.0F * this.sEnergy); + } + } + return true; + } + + @Override + public boolean canStoreHeat(IReactor reactor, ItemStack yourStack, int x, int y) { + return false; + } + + @Override + public int getMaxHeat(IReactor reactor, ItemStack yourStack, int x, int y) { + return 0; + } + + @Override + public int getCurrentHeat(IReactor reactor, ItemStack yourStack, int x, int y) { + return 0; + } + + @Override + public int alterHeat(IReactor reactor, ItemStack yourStack, int x, int y, int heat) { + return heat; + } + + @Override + public float influenceExplosion(IReactor reactor, ItemStack yourStack) { + return 2 * this.numberOfCells; + } + + @Override + public void onUpdate(ItemStack stack, World world, Entity entity, int slotIndex, boolean isCurrentItem) { + if (this.sRadiation > 0 && (entity instanceof EntityLivingBase entityLiving)) { + if (!GT_Utility.isWearingFullRadioHazmat(entityLiving)) { + IC2Potion.radiation.applyTo(entityLiving, sRadiation * 20, sRadiation * 10); + } + } + } + + private static class ItemStackCoord { + + public ItemStack stack; + public int x; + public int y; + + public ItemStackCoord(ItemStack stack1, int x1, int y1) { + this.stack = stack1; + this.x = x1; + this.y = y1; + } + } +} diff --git a/src/main/java/gregtech/api/items/GT_RadioactiveCell_Item.java b/src/main/java/gregtech/api/items/GT_RadioactiveCell_Item.java new file mode 100644 index 0000000000..c927737889 --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_RadioactiveCell_Item.java @@ -0,0 +1,159 @@ +package gregtech.api.items; + +import static gregtech.api.util.GT_Utility.formatNumbers; + +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; + +import gregtech.common.items.GT_DepletetCell_Item; +import ic2.api.item.IBoxable; +import ic2.core.util.StackUtil; + +public class GT_RadioactiveCell_Item extends GT_Generic_Item implements IBoxable { + + protected int cellCount; + protected int maxDmg; + protected int dura; + + public GT_RadioactiveCell_Item(String aUnlocalized, String aEnglish, int aCellcount) { + super(aUnlocalized, aEnglish, null); + this.setMaxStackSize(64); + this.setMaxDamage(100); + setNoRepair(); + this.cellCount = Math.max(1, aCellcount); + } + + public static int getDurabilityOfStack(ItemStack aStack) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + tNBT = new NBTTagCompound(); + aStack.setTagCompound(tNBT); + } + return tNBT.getInteger("advDmg"); + } + + protected static int sumUp(int a) { + int b = 0; + for (int c = 1; c <= a; c++) { + b += c; + } + return b; + } + + protected static int triangularNumber(int x) { + return (x * x + x) / 2; + } + + protected boolean outputPulseForStack(ItemStack aStack) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + tNBT = new NBTTagCompound(); + aStack.setTagCompound(tNBT); + } + tNBT.setInteger("output", tNBT.getInteger("output") + 1); + return false; // (this.pulserate > 0) || (tNBT.getInteger("output") % -this.pulserate == 0); + } + + protected boolean incrementPulseForStack(ItemStack aStack) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + tNBT = new NBTTagCompound(); + aStack.setTagCompound(tNBT); + } + tNBT.setInteger("pulse", tNBT.getInteger("pulse") + 1); + return false; // (this.pulserate > 0) || (tNBT.getInteger("pulse") % -this.pulserate == 0); + } + + protected void setDurabilityForStack(ItemStack aStack, int aDurability) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + tNBT = new NBTTagCompound(); + aStack.setTagCompound(tNBT); + } + tNBT.setInteger("durability", aDurability); + } + + public int getMaxNuclearDurability() { + return 0; // return this.maxDelay; + } + + public int func_77619_b() { + return 0; + } + + @Override + public boolean isBookEnchantable(ItemStack ingredient, ItemStack bookEnchant) { + return false; + } + + // getIsRepairable + public boolean func_82789_a(ItemStack toBeRepaired, ItemStack repairWith) { + return false; + } + + public void setDamageForStack(ItemStack stack, int advDmg) { + NBTTagCompound nbtData = StackUtil.getOrCreateNbtData(stack); + nbtData.setInteger("advDmg", advDmg); + if (this.maxDmg > 0) { + double p = (double) advDmg / (double) this.maxDmg; + int newDmg = (int) (stack.getMaxDamage() * p); + if (newDmg >= stack.getMaxDamage()) { + newDmg = stack.getMaxDamage() - 1; + } + stack.setItemDamage(newDmg); + this.dura = newDmg; + } + } + + public int getDamageOfStack(ItemStack stack) { + NBTTagCompound nbtData = StackUtil.getOrCreateNbtData(stack); + this.dura = nbtData.getInteger("advDmg"); + return this.dura; + } + + public int getControlTagOfStack(ItemStack stack) { + NBTTagCompound nbtData = StackUtil.getOrCreateNbtData(stack); + return nbtData.getInteger("tag"); + } + + public void setControlTagOfStack(ItemStack stack, int tag) { + NBTTagCompound nbtData = StackUtil.getOrCreateNbtData(stack); + nbtData.setInteger("tag", tag); + } + + public int getMaxDamageEx() { + return this.maxDmg; + } + + public void damageItemStack(ItemStack stack, int Dmg) { + setDamageForStack(stack, getDamageOfStack(stack) + Dmg); + } + + @Override + public void addAdditionalToolTips(List<String> aList, ItemStack aStack, EntityPlayer aPlayer) { + super.addAdditionalToolTips(aList, aStack, aPlayer); + // aList.add("Time left: " + (this.maxDelay - getDurabilityOfStack(aStack)) + " secs"); + int rDmg = getDurabilityOfStack(aStack) * 6 / this.maxDmg; + EnumChatFormatting color2 = switch (rDmg) { + case 0, 1 -> EnumChatFormatting.WHITE; + case 2, 3, 4 -> EnumChatFormatting.GRAY; + default -> EnumChatFormatting.DARK_GRAY; + }; + EnumChatFormatting color1 = this instanceof GT_DepletetCell_Item ? color2 = EnumChatFormatting.DARK_GRAY + : EnumChatFormatting.WHITE; + aList.add( + color1 + String.format( + transItem("001", "Durability: %s/%s"), + "" + color2 + formatNumbers(this.maxDmg - getDurabilityOfStack(aStack)) + color1, + "" + formatNumbers(this.maxDmg))); + } + + @Override + public boolean canBeStoredInToolbox(ItemStack itemstack) { + return true; + } +} diff --git a/src/main/java/gregtech/api/items/GT_Tool_Item.java b/src/main/java/gregtech/api/items/GT_Tool_Item.java new file mode 100644 index 0000000000..9f78bdc3fc --- /dev/null +++ b/src/main/java/gregtech/api/items/GT_Tool_Item.java @@ -0,0 +1,41 @@ +package gregtech.api.items; + +import net.minecraft.item.ItemStack; + +import gregtech.api.util.GT_ModHandler; + +/** + * This is just a basic Tool, which has normal durability and could break Blocks. + */ +public class GT_Tool_Item extends GT_Generic_Item { + + public GT_Tool_Item(String aUnlocalized, String aEnglish, String aTooltip, int aMaxDamage, int aEntityDamage, + boolean aSwingIfUsed) { + this(aUnlocalized, aEnglish, aTooltip, aMaxDamage, aEntityDamage, aSwingIfUsed, -1, -1); + } + + public GT_Tool_Item(String aUnlocalized, String aEnglish, String aTooltip, int aMaxDamage, int aEntityDamage, + boolean aSwingIfUsed, int aChargedGTID, int aDisChargedGTID) { + this( + aUnlocalized, + aEnglish, + aTooltip, + aMaxDamage, + aEntityDamage, + aSwingIfUsed, + aChargedGTID, + aDisChargedGTID, + 0, + 0.0F); + } + + public GT_Tool_Item(String aUnlocalized, String aEnglish, String aTooltip, int aMaxDamage, int aEntityDamage, + boolean aSwingIfUsed, int aChargedGTID, int aDisChargedGTID, int aToolQuality, float aToolStrength) { + super(aUnlocalized, aEnglish, aTooltip); + setMaxDamage(aMaxDamage); + setMaxStackSize(1); + setNoRepair(); + setFull3D(); + GT_ModHandler.registerBoxableItemToToolBox(new ItemStack(this)); + } +} |