diff options
Diffstat (limited to 'src/Java/gtPlusPlus/core')
49 files changed, 3755 insertions, 704 deletions
diff --git a/src/Java/gtPlusPlus/core/block/ModBlocks.java b/src/Java/gtPlusPlus/core/block/ModBlocks.java index f95f8814a9..2b04356f52 100644 --- a/src/Java/gtPlusPlus/core/block/ModBlocks.java +++ b/src/Java/gtPlusPlus/core/block/ModBlocks.java @@ -1,23 +1,32 @@ package gtPlusPlus.core.block; -import cpw.mods.fml.common.registry.GameRegistry; - -import net.minecraft.block.Block; -import net.minecraft.block.BlockJukebox; -import net.minecraft.block.material.Material; - import gtPlusPlus.api.objects.Logger; -import gtPlusPlus.core.block.base.BasicBlock.BlockTypes; -import gtPlusPlus.core.block.base.BlockBaseOre; -import gtPlusPlus.core.block.general.*; +import gtPlusPlus.core.block.general.BlockCompressedObsidian; +import gtPlusPlus.core.block.general.BlockNet; +import gtPlusPlus.core.block.general.BlockTankXpConverter; +import gtPlusPlus.core.block.general.FirePit; +import gtPlusPlus.core.block.general.FluidTankInfinite; +import gtPlusPlus.core.block.general.HellFire; +import gtPlusPlus.core.block.general.LightGlass; +import gtPlusPlus.core.block.general.MiningExplosives; +import gtPlusPlus.core.block.general.PlayerDoors; import gtPlusPlus.core.block.general.antigrief.BlockWitherProof; -import gtPlusPlus.core.block.machine.*; +import gtPlusPlus.core.block.machine.CircuitProgrammer; +import gtPlusPlus.core.block.machine.DecayablesChest; +import gtPlusPlus.core.block.machine.FishTrap; +import gtPlusPlus.core.block.machine.HeliumGenerator; +import gtPlusPlus.core.block.machine.Machine_ModularityTable; +import gtPlusPlus.core.block.machine.Machine_PooCollector; +import gtPlusPlus.core.block.machine.Machine_ProjectTable; +import gtPlusPlus.core.block.machine.Machine_SuperJukebox; +import gtPlusPlus.core.block.machine.Machine_TradeTable; +import gtPlusPlus.core.block.machine.Machine_Workbench; +import gtPlusPlus.core.block.machine.Machine_WorkbenchAdvanced; import gtPlusPlus.core.block.machine.bedrock.Mining_Head_Fake; import gtPlusPlus.core.block.machine.bedrock.Mining_Pipe_Fake; import gtPlusPlus.core.fluids.FluidRegistryHandler; -import gtPlusPlus.core.lib.CORE; -import gtPlusPlus.core.util.Utils; -import gtPlusPlus.plugin.villagers.block.BlockGenericSpawner; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; import net.minecraftforge.fluids.Fluid; public final class ModBlocks { @@ -78,6 +87,8 @@ public final class ModBlocks { public static Block blockCustomMobSpawner; public static Block blockCustomSuperLight; public static Block blockCustomJukebox; + + public static Block blockPooCollector; public static void init() { Logger.INFO("Initializing Blocks."); @@ -127,6 +138,8 @@ public final class ModBlocks { //blockCustomSuperLight = new BlockSuperLight(); blockCustomJukebox = new Machine_SuperJukebox(); + + blockPooCollector = new Machine_PooCollector(); } diff --git a/src/Java/gtPlusPlus/core/block/machine/Machine_PooCollector.java b/src/Java/gtPlusPlus/core/block/machine/Machine_PooCollector.java new file mode 100644 index 0000000000..23fdfe9733 --- /dev/null +++ b/src/Java/gtPlusPlus/core/block/machine/Machine_PooCollector.java @@ -0,0 +1,180 @@ +package gtPlusPlus.core.block.machine; + +import java.util.List; +import java.util.Random; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gtPlusPlus.core.creative.AddToCreativeTab; +import gtPlusPlus.core.item.base.itemblock.ItemBlockMeta; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.tileentities.machines.TileEntityAdvPooCollector; +import gtPlusPlus.core.tileentities.machines.TileEntityBaseFluidCollector; +import gtPlusPlus.core.tileentities.machines.TileEntityPooCollector; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.PlayerUtils; +import net.minecraft.block.BlockContainer; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; + +public class Machine_PooCollector extends BlockContainer { + + @SideOnly(Side.CLIENT) + private IIcon textureTop; + @SideOnly(Side.CLIENT) + private IIcon textureTop2; + @SideOnly(Side.CLIENT) + private IIcon textureSide; + @SideOnly(Side.CLIENT) + private IIcon textureSide2; + + public Machine_PooCollector() { + super(Material.iron); + this.setBlockName("blockPooCollector"); + this.setCreativeTab(AddToCreativeTab.tabMachines); + GameRegistry.registerBlock(this, ItemBlockMeta.class,"blockPooCollector"); + } + + /** + * Gets the block's texture. Args: side, meta + */ + @Override + @SideOnly(Side.CLIENT) + public IIcon getIcon(final int aSide, final int aMeta) { + if (aMeta <= 7) { + blockIcon = textureSide; + return aSide <= 1 ? this.textureTop : this.textureSide; + } + else { + blockIcon = textureSide2; + return aSide <= 1 ? this.textureTop2 : this.textureSide2; + } + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(final IIconRegister p_149651_1_) { + this.textureTop = p_149651_1_.registerIcon(CORE.MODID + ":" + "TileEntities/" + "sewer_top"); + this.textureTop2 = p_149651_1_.registerIcon(CORE.MODID + ":" + "TileEntities/" + "sewer_adv_top"); + this.textureSide = p_149651_1_.registerIcon(CORE.MODID + ":" + "TileEntities/" + "sewer_sides"); + this.textureSide2 = p_149651_1_.registerIcon(CORE.MODID + ":" + "TileEntities/" + "sewer_adv_sides"); + } + + /** + * Called upon block activation (right click on the block.) + */ + @Override + public boolean onBlockActivated(final World world, final int x, final int y, final int z, final EntityPlayer player, + final int side, final float lx, final float ly, final float lz) { + if (world.isRemote) { + return true; + } else { + TileEntityBaseFluidCollector tank = (TileEntityBaseFluidCollector) world.getTileEntity(x, y, z); + if (tank != null) { + Item handItem; + try { + handItem = player.getHeldItem().getItem(); + } catch (Throwable t) { + handItem = null; + } + + //Fluid container code + /*if (handItem != null + && (handItem instanceof IFluidContainerItem || handItem instanceof ItemFluidContainer + || FluidContainerRegistry.isFilledContainer(player.getHeldItem()))) { + if (tank.tank.getFluid() == null) { + try { + if (!FluidContainerRegistry.isFilledContainer(player.getHeldItem())) { + ItemStack handItemStack = player.getHeldItem(); + IFluidContainerItem container = (IFluidContainerItem) handItem; + FluidStack containerFluid = container.getFluid(handItemStack); + container.drain(handItemStack, container.getFluid(handItemStack).amount, true); + tank.tank.setFluid(containerFluid); + } else { + ItemStack handItemStack = player.getHeldItem(); + FluidContainerRegistry.drainFluidContainer(handItemStack); + FluidStack containerFluid = FluidContainerRegistry.getFluidForFilledItem(handItemStack); + ItemStack emptyContainer = FluidContainerRegistry.drainFluidContainer(handItemStack); + player.setItemInUse(emptyContainer, 0); + + tank.tank.setFluid(containerFluid); + } + } catch (Throwable t) { + t.printStackTrace(); + } + } + + }*/ + + if (!tank.mInventory.isEmpty()) { + PlayerUtils.messagePlayer(player, "Inventory contains:"); + PlayerUtils.messagePlayer(player, ItemUtils.getArrayStackNames(tank.mInventory.getRealInventory())); + } + else { + PlayerUtils.messagePlayer(player, "No solids collected yet."); + } + if (tank.tank.getFluid() != null) { + PlayerUtils.messagePlayer(player, "Tank contains " + tank.tank.getFluidAmount() + "L of " + + tank.tank.getFluid().getLocalizedName()); + } + } + } + return true; + } + + @Override + public int getRenderBlockPass() { + return 0; + } + + @Override + public boolean isOpaqueCube() { + return super.isOpaqueCube(); + } + + @Override + public TileEntity createNewTileEntity(final World world, final int aMeta) { + return aMeta <= 7 ? new TileEntityPooCollector() : new TileEntityAdvPooCollector(); + } + + @Override + public void onBlockAdded(World world, int x, int y, int z) { + super.onBlockAdded(world, x, y, z); + } + + @Override + public int getBlockColor() { + // TODO Auto-generated method stub + return 0; + } + + @Override + public int damageDropped(final int damage) { + return damage; + } + + @Override + public Item getItemDropped(final int meta, final Random rand, final int fortune) { + return Item.getItemFromBlock(this); + } + + @Override + public int getRenderColor(int aMeta) { + return super.getRenderColor(aMeta); + } + + @Override + public void getSubBlocks(Item aItem, CreativeTabs aTab, List aList) { + aList.add(new ItemStack(aItem, 1, 0)); + aList.add(new ItemStack(aItem, 1, 8)); + } + +} diff --git a/src/Java/gtPlusPlus/core/common/CommonProxy.java b/src/Java/gtPlusPlus/core/common/CommonProxy.java index 03b643abdb..301ca992a4 100644 --- a/src/Java/gtPlusPlus/core/common/CommonProxy.java +++ b/src/Java/gtPlusPlus/core/common/CommonProxy.java @@ -18,6 +18,7 @@ import gtPlusPlus.core.entity.InternalEntityRegistry; import gtPlusPlus.core.entity.monster.EntityGiantChickenBase; import gtPlusPlus.core.entity.monster.EntitySickBlaze; import gtPlusPlus.core.entity.monster.EntityStaballoyConstruct; +import gtPlusPlus.core.fluids.FluidFactory; import gtPlusPlus.core.handler.BookHandler; import gtPlusPlus.core.handler.BurnableFuelHandler; import gtPlusPlus.core.handler.COMPAT_HANDLER; @@ -81,7 +82,7 @@ public class CommonProxy { ModItems.init(); ModBlocks.init(); CI.preInit(); - + FluidFactory.preInit(); COMPAT_IntermodStaging.preInit(e); BookHandler.run(); // Registration of entities and renderers @@ -117,6 +118,7 @@ public class CommonProxy { Logger.ERROR("[ERROR] Did not generate fluids at all."); } CI.init(); + FluidFactory.init(); /** * Register the Event Handlers. @@ -158,6 +160,7 @@ public class CommonProxy { public void postInit(final FMLPostInitializationEvent e) { Logger.INFO("Cleaning up, doing postInit."); PlayerCache.initCache(); + FluidFactory.postInit(); // Make Burnables burnable if (!CORE.burnables.isEmpty()) { @@ -180,6 +183,7 @@ public class CommonProxy { public void onLoadComplete(FMLLoadCompleteEvent event) { COMPAT_IntermodStaging.onLoadComplete(event); + COMPAT_HANDLER.onLoadComplete(event); } public void registerNetworkStuff() { diff --git a/src/Java/gtPlusPlus/core/common/compat/COMPAT_CompactWindmills.java b/src/Java/gtPlusPlus/core/common/compat/COMPAT_CompactWindmills.java index a5d0768e72..cd5d36b653 100644 --- a/src/Java/gtPlusPlus/core/common/compat/COMPAT_CompactWindmills.java +++ b/src/Java/gtPlusPlus/core/common/compat/COMPAT_CompactWindmills.java @@ -40,17 +40,17 @@ public class COMPAT_CompactWindmills { public static ItemStack evWindmill = ItemUtils.simpleMetaStack("CompactWindmills:blockCompactWindmill", 4, 1); //Compact Rotors - public static ItemStack rotor2 = ItemUtils.getItemStack("CompactWindmills:WOOL", 1); - public static ItemStack rotor1 = ItemUtils.getItemStack("CompactWindmills:WOOD", 1); - public static ItemStack rotor3 = ItemUtils.getItemStack("CompactWindmills:ALLOY", 1); - public static ItemStack rotor4 = ItemUtils.getItemStack("CompactWindmills:CARBON", 1); - public static ItemStack rotor5 = ItemUtils.getItemStack("CompactWindmills:IRIDIUM", 1); + public static ItemStack rotor2 = ItemUtils.getItemStackFromFQRN("CompactWindmills:WOOL", 1); + public static ItemStack rotor1 = ItemUtils.getItemStackFromFQRN("CompactWindmills:WOOD", 1); + public static ItemStack rotor3 = ItemUtils.getItemStackFromFQRN("CompactWindmills:ALLOY", 1); + public static ItemStack rotor4 = ItemUtils.getItemStackFromFQRN("CompactWindmills:CARBON", 1); + public static ItemStack rotor5 = ItemUtils.getItemStackFromFQRN("CompactWindmills:IRIDIUM", 1); //IC2 Rotors - public static ItemStack rotorIC1 = ItemUtils.getItemStack("IC2:itemwoodrotor", 1); - public static ItemStack rotorIC2 = ItemUtils.getItemStack("IC2:itemironrotor", 1); - public static ItemStack rotorIC3 = ItemUtils.getItemStack("IC2:itemsteelrotor", 1); - public static ItemStack rotorIC4 = ItemUtils.getItemStack("IC2:itemwcarbonrotor", 1); + public static ItemStack rotorIC1 = ItemUtils.getItemStackFromFQRN("IC2:itemwoodrotor", 1); + public static ItemStack rotorIC2 = ItemUtils.getItemStackFromFQRN("IC2:itemironrotor", 1); + public static ItemStack rotorIC3 = ItemUtils.getItemStackFromFQRN("IC2:itemsteelrotor", 1); + public static ItemStack rotorIC4 = ItemUtils.getItemStackFromFQRN("IC2:itemwcarbonrotor", 1); public static ItemStack rotorBlade1 = ItemUtils.simpleMetaStack("IC2:itemRecipePart", 7, 1); public static ItemStack rotorBlade2 = ItemUtils.simpleMetaStack("IC2:itemRecipePart", 8, 1); public static ItemStack rotorBlade3 = ItemUtils.simpleMetaStack("IC2:itemRecipePart", 10, 1); diff --git a/src/Java/gtPlusPlus/core/common/compat/COMPAT_ExtraUtils.java b/src/Java/gtPlusPlus/core/common/compat/COMPAT_ExtraUtils.java index 45a70997e4..4d736e1362 100644 --- a/src/Java/gtPlusPlus/core/common/compat/COMPAT_ExtraUtils.java +++ b/src/Java/gtPlusPlus/core/common/compat/COMPAT_ExtraUtils.java @@ -10,7 +10,7 @@ import gtPlusPlus.core.util.minecraft.RecipeUtils; public class COMPAT_ExtraUtils { public static void OreDict(){ - RECIPES_Tools.RECIPE_DivisionSigil = new ItemStack(ItemUtils.getItem("ExtraUtilities:divisionSigil")); + RECIPES_Tools.RECIPE_DivisionSigil = new ItemStack(ItemUtils.getItemFromFQRN("ExtraUtilities:divisionSigil")); run(); } diff --git a/src/Java/gtPlusPlus/core/common/compat/COMPAT_OpenBlocks.java b/src/Java/gtPlusPlus/core/common/compat/COMPAT_OpenBlocks.java index c7b90b780c..6381a6705e 100644 --- a/src/Java/gtPlusPlus/core/common/compat/COMPAT_OpenBlocks.java +++ b/src/Java/gtPlusPlus/core/common/compat/COMPAT_OpenBlocks.java @@ -13,7 +13,7 @@ public class COMPAT_OpenBlocks { private static final void run(){ - Item aGraveItem = ItemUtils.getItem("OpenBlocks:grave"); + Item aGraveItem = ItemUtils.getItemFromFQRN("OpenBlocks:grave"); if (aGraveItem == null) { return; } diff --git a/src/Java/gtPlusPlus/core/common/compat/COMPAT_Thaumcraft.java b/src/Java/gtPlusPlus/core/common/compat/COMPAT_Thaumcraft.java index 6247face1d..b78c10c8ce 100644 --- a/src/Java/gtPlusPlus/core/common/compat/COMPAT_Thaumcraft.java +++ b/src/Java/gtPlusPlus/core/common/compat/COMPAT_Thaumcraft.java @@ -20,9 +20,9 @@ public class COMPAT_Thaumcraft { for(int i=0; i<=6; i++){ //Utils.LOG_INFO(""+i); ItemUtils.getItemForOreDict("Thaumcraft:ItemShard", "shardAny", "TC Shard "+i, i); - GT_OreDictUnificator.registerOre("shardAny", ItemUtils.getItemStack("Thaumcraft:ItemShard:"+i, 1)); + GT_OreDictUnificator.registerOre("shardAny", ItemUtils.getItemStackFromFQRN("Thaumcraft:ItemShard:"+i, 1)); ItemUtils.getItemForOreDict("Thaumcraft:ItemShard", "gemInfusedAnything", "TC Shard "+i, i); - GT_OreDictUnificator.registerOre("gemInfusedAnything", ItemUtils.getItemStack("Thaumcraft:ItemShard:"+i, 1)); + GT_OreDictUnificator.registerOre("gemInfusedAnything", ItemUtils.getItemStackFromFQRN("Thaumcraft:ItemShard:"+i, 1)); //System.out.println("TC Shard registration count is: "+i); } @@ -30,15 +30,15 @@ public class COMPAT_Thaumcraft { for(int i=0; i<=6; i++){ //Utils.LOG_INFO(""+i); ItemUtils.getItemForOreDict("ForbiddenMagic:NetherShard", "shardAny", "FM Shard "+i, i); - GT_OreDictUnificator.registerOre("shardAny", ItemUtils.getItemStack("ForbiddenMagic:NetherShard:"+i, 1)); + GT_OreDictUnificator.registerOre("shardAny", ItemUtils.getItemStackFromFQRN("ForbiddenMagic:NetherShard:"+i, 1)); ItemUtils.getItemForOreDict("ForbiddenMagic:NetherShard", "gemInfusedAnything", "FM Shard "+i, i); - GT_OreDictUnificator.registerOre("gemInfusedAnything", ItemUtils.getItemStack("ForbiddenMagic:NetherShard:"+i, 1)); + GT_OreDictUnificator.registerOre("gemInfusedAnything", ItemUtils.getItemStackFromFQRN("ForbiddenMagic:NetherShard:"+i, 1)); //System.out.println("TC Shard registration count is: "+i); } ItemUtils.getItemForOreDict("ForbiddenMagic:GluttonyShard", "shardAny", "FM Gluttony Shard", 0); - GT_OreDictUnificator.registerOre("shardAny", ItemUtils.getItemStack("ForbiddenMagic:GluttonyShard", 1)); + GT_OreDictUnificator.registerOre("shardAny", ItemUtils.getItemStackFromFQRN("ForbiddenMagic:GluttonyShard", 1)); ItemUtils.getItemForOreDict("ForbiddenMagic:GluttonyShard", "gemInfusedAnything", "FM Gluttony Shard", 0); - GT_OreDictUnificator.registerOre("gemInfusedAnything", ItemUtils.getItemStack("ForbiddenMagic:GluttonyShard", 1)); + GT_OreDictUnificator.registerOre("gemInfusedAnything", ItemUtils.getItemStackFromFQRN("ForbiddenMagic:GluttonyShard", 1)); } } diff --git a/src/Java/gtPlusPlus/core/config/ConfigHandler.java b/src/Java/gtPlusPlus/core/config/ConfigHandler.java index 2fbd3f60c2..64c8b74b33 100644 --- a/src/Java/gtPlusPlus/core/config/ConfigHandler.java +++ b/src/Java/gtPlusPlus/core/config/ConfigHandler.java @@ -46,7 +46,9 @@ public class ConfigHandler { enableAlternativeDivisionSigilRecipe = config.getBoolean("enableAlternativeDivisionSigilRecipe", "machines", false, "Utilizes Neutronium instead."); boilerSteamPerSecond = config.getInt("boilerSteamPerSecond", "machines", 750, 0, 10000, "Sets the steam per second value in LV,MV,HV boilers (respectively 1x,2x,3x this number for the tiers)"); - requireControlCores = config.getBoolean("requireControlCores", "machines", true, "Multiblocks Require Control Cores"); + + //requireControlCores + boolean temp = config.getBoolean("requireControlCores", "machines", true, "Multiblocks Require Control Cores"); diff --git a/src/Java/gtPlusPlus/core/entity/InternalEntityRegistry.java b/src/Java/gtPlusPlus/core/entity/InternalEntityRegistry.java index 36f5b86184..e5c779adcf 100644 --- a/src/Java/gtPlusPlus/core/entity/InternalEntityRegistry.java +++ b/src/Java/gtPlusPlus/core/entity/InternalEntityRegistry.java @@ -14,6 +14,7 @@ import gtPlusPlus.core.entity.monster.EntitySickBlaze; import gtPlusPlus.core.entity.monster.EntityStaballoyConstruct; import gtPlusPlus.core.entity.projectile.EntityHydrofluoricAcidPotion; import gtPlusPlus.core.entity.projectile.EntitySulfuricAcidPotion; +import gtPlusPlus.core.entity.projectile.EntityThrowableBomb; import gtPlusPlus.core.entity.projectile.EntityToxinballSmall; import gtPlusPlus.core.util.Utils; @@ -51,6 +52,8 @@ public class InternalEntityRegistry { //EntityRegistry.registerGlobalEntityID(EntityTeslaTowerLightning.class, "plasmaBolt", EntityRegistry.findGlobalUniqueEntityId(), Utils.rgbtoHexValue(255, 0, 0), Utils.rgbtoHexValue(125, 125, 125)); EntityRegistry.registerModEntity(EntityTeslaTowerLightning.class, "plasmaBolt", mEntityID++, GTplusplus.instance, 64, 5, true); + EntityRegistry.registerModEntity(EntityThrowableBomb.class, "EntityThrowableBomb", mEntityID++, GTplusplus.instance, 64, 10, true); + /** * Globals, which generate spawn eggs. (Currently required for Giant chicken spawning) */ diff --git a/src/Java/gtPlusPlus/core/entity/projectile/EntityThrowableBomb.java b/src/Java/gtPlusPlus/core/entity/projectile/EntityThrowableBomb.java new file mode 100644 index 0000000000..9e72daf687 --- /dev/null +++ b/src/Java/gtPlusPlus/core/entity/projectile/EntityThrowableBomb.java @@ -0,0 +1,115 @@ +package gtPlusPlus.core.entity.projectile; + +import net.minecraft.block.Block; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.projectile.EntityThrowable; +import net.minecraft.init.Blocks; +import net.minecraft.util.DamageSource; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.world.World; + +import gregtech.api.util.GT_Utility; + +import gtPlusPlus.api.objects.minecraft.BlockPos; +import gtPlusPlus.core.util.math.MathUtils; +import gtPlusPlus.core.util.minecraft.EntityUtils; + +public class EntityThrowableBomb extends EntityThrowable { + + public EntityThrowableBomb(World world) { + super(world); + } + + public EntityThrowableBomb(World world, EntityLivingBase entity) { + super(world, entity); + } + + public EntityThrowableBomb(World world, double posX, double posY, double posZ) { + super(world, posX, posY, posZ); + } + + /** + * Called when this EntityThrowable hits a block or entity. + */ + @Override + protected void onImpact(MovingObjectPosition object) { + int xBlock = object.blockX; + int yBlock = object.blockY; + int zBlock = object.blockZ; + if (object.entityHit != null) { + byte b0 = 6; + if (!GT_Utility.isWearingFullRadioHazmat((EntityLivingBase) object.entityHit)){ + object.entityHit.attackEntityFrom(DamageSource.causeThrownDamage(this, this.getThrower()), b0); + EntityUtils.setEntityOnFire(object.entityHit, 10); + object.entityHit.fireResistance = 0; + ravage(EntityUtils.findBlockPosUnderEntity(object.entityHit)); + } + } + if (object.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK){ + ravage(new BlockPos(xBlock, yBlock, zBlock)); + } + + String mParticleType = "reddust"; + int e=0; + for (int i = 0; i < 24; ++i) { + if ((e = MathUtils.randInt(0, 5)) <= 1){ + if (e==0) + mParticleType = "largesmoke"; + if (e==1) + mParticleType = "flame"; + } + this.worldObj.spawnParticle(mParticleType, this.posX+MathUtils.randDouble(-2, 2), this.posY+MathUtils.randDouble(-2, 2), this.posZ+MathUtils.randDouble(-2, 2), 0.0D, 0.0D, 0.0D); + } + + if (!this.worldObj.isRemote) { + this.setDead(); + } + } + + private boolean ravage(BlockPos blockpos){ + + int radius = 1; + + for (int i=(blockpos.xPos-radius);i<(blockpos.xPos+radius);i++){ + for (int j=(blockpos.yPos-radius);j<(blockpos.yPos+radius);j++){ + for (int h=(blockpos.zPos-radius);h<(blockpos.zPos+radius);h++){ + + int mChance = MathUtils.randInt(1, 10); + if (mChance <= 3){ + Block mBlockhit = worldObj.getBlock(i, j, h); + this.worldObj.spawnParticle("flame", this.posX+MathUtils.randDouble(-2, 2), this.posY+MathUtils.randDouble(-2, 2), this.posZ+MathUtils.randDouble(-2, 2), 0.0D, 0.0D, 0.0D); + this.worldObj.spawnParticle("largesmoke", this.posX+MathUtils.randDouble(2, 2), this.posY+MathUtils.randDouble(-2, 2), this.posZ+MathUtils.randDouble(-2, 2), 0.0D, 0.0D, 0.0D); + + //GT_Pollution.addPollution(worldObj.getChunkFromBlockCoords(blockpos.xPos, blockpos.zPos), mPol); + this.worldObj.createExplosion(this, this.posX, this.posY, this.posZ, 0.01f, true); + if (mBlockhit == Blocks.grass || mBlockhit == Blocks.mycelium){ + worldObj.setBlock(i, j+1, h, Blocks.fire); + worldObj.setBlock(i, j, h, Blocks.dirt); + } + else if (mBlockhit == Blocks.leaves || mBlockhit == Blocks.leaves2){ + worldObj.setBlock(i, j, h, Blocks.fire); + } + else if (mBlockhit == Blocks.tallgrass){ + worldObj.setBlock(i, j, h, Blocks.fire); + if (worldObj.getBlock(i, j-1, h) == Blocks.grass){ + worldObj.setBlock(i, j-1, h, Blocks.dirt); + } + } + else if (mBlockhit == Blocks.carrots || mBlockhit == Blocks.melon_block || mBlockhit == Blocks.pumpkin || mBlockhit == Blocks.potatoes){ + worldObj.setBlock(i, j+1, h, Blocks.fire); + worldObj.setBlock(i, j, h, Blocks.dirt); + } + else if (mBlockhit == Blocks.air){ + worldObj.setBlock(i, j, h, Blocks.fire); + } + } + } + } + } + + + return true; + } + + +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/core/fluids/BlockFluidBase.java b/src/Java/gtPlusPlus/core/fluids/BlockFluidBase.java index 9a3958a908..dc7c9c2e78 100644 --- a/src/Java/gtPlusPlus/core/fluids/BlockFluidBase.java +++ b/src/Java/gtPlusPlus/core/fluids/BlockFluidBase.java @@ -1,113 +1,104 @@ package gtPlusPlus.core.fluids; -import cpw.mods.fml.common.registry.LanguageRegistry; import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; - +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.util.Utils; +import net.minecraft.block.material.Material; import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; import net.minecraft.util.IIcon; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; - -import gtPlusPlus.core.creative.AddToCreativeTab; -import gtPlusPlus.core.lib.CORE; -import gtPlusPlus.core.material.Material; -import gtPlusPlus.core.util.Utils; -import gtPlusPlus.core.util.math.MathUtils; +import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.BlockFluidClassic; import net.minecraftforge.fluids.Fluid; public class BlockFluidBase extends BlockFluidClassic { @SideOnly(Side.CLIENT) - protected IIcon stillIcon; + protected static IIcon stillIcon; @SideOnly(Side.CLIENT) - protected IIcon flowingIcon; - - protected int colour; - protected Material fluidMaterial; - final String displayName; - - @SuppressWarnings("deprecation") - public BlockFluidBase(final Fluid fluid, final Material material) { - super(fluid, net.minecraft.block.material.Material.lava); - final short[] tempColour = material.getRGBA(); - this.colour = Utils.rgbtoHexValue(tempColour[0], tempColour[1], tempColour[2]); - this.fluidMaterial = material; - this.setCreativeTab(AddToCreativeTab.tabOther); - this.displayName = material.getLocalizedName(); - LanguageRegistry.addName(this, "Molten "+this.displayName+" ["+MathUtils.celsiusToKelvin(this.fluidMaterial.getBoilingPointC())+"K]"); - this.setBlockName(this.GetProperName()); + protected static IIcon flowingIcon; + + protected final short[] mRGB; + + + public BlockFluidBase(Fluid fluid, short[] aRGB) { + this(fluid, Material.water, aRGB); } - @SuppressWarnings("deprecation") - public BlockFluidBase(final String fluidName, final Fluid fluid, final short[] colour) { - super(fluid, net.minecraft.block.material.Material.lava); - final short[] tempColour = colour; - this.colour = Utils.rgbtoHexValue(tempColour[0], tempColour[1], tempColour[2]); - this.setCreativeTab(AddToCreativeTab.tabOther); - this.displayName = fluidName; - LanguageRegistry.addName(this, "Molten "+this.displayName); - this.setBlockName(this.GetProperName()); + public BlockFluidBase(Fluid fluid, Material material, short[] aRGB) { + super(fluid, material); + mRGB = aRGB; + this.setHardness(100.0F); + this.setLightOpacity(3); + this.disableStats(); } @Override - public IIcon getIcon(final int side, final int meta) { - return ((side == 0) || (side == 1))? this.stillIcon : this.flowingIcon; + public void onEntityCollidedWithBlock(World world, int x, int y, int z, Entity ent) { + if (!(ent instanceof EntityLivingBase)) { + return; + } + /*EntityLivingBase player = (EntityLivingBase) ent; + int pot = world.rand.nextInt(Potion.potionTypes.length); + Potion.potionTypes[pot].performEffect(player, 40);*/ } - @SideOnly(Side.CLIENT) @Override - public void registerBlockIcons(final IIconRegister register) { - this.stillIcon = register.registerIcon(CORE.MODID+":fluids/fluid.molten.autogenerated"); - this.flowingIcon = register.registerIcon(CORE.MODID+":fluids/fluid.molten.autogenerated"); + public IIcon getIcon(int side, int meta) { + return (side == 0 || side == 1) ? stillIcon : flowingIcon; } + @SideOnly(Side.CLIENT) @Override - public boolean canDisplace(final IBlockAccess world, final int x, final int y, final int z) { - if (world.getBlock(x, y, z).getMaterial().isLiquid()) { - return false; + public void registerBlockIcons(IIconRegister register) { + if (stillIcon == null) { + stillIcon = register.registerIcon(CORE.MODID+ ":" + "fluids/fluid.fluid.autogenerated.still"); } - return super.canDisplace(world, x, y, z); + if (flowingIcon == null) { + flowingIcon = register.registerIcon(CORE.MODID+ ":" + "fluids/fluid.fluid.autogenerated.flowing"); + } } @Override - public boolean displaceIfPossible(final World world, final int x, final int y, final int z) { - if (world.getBlock(x, y, z).getMaterial().isLiquid()) { - return false; - } - return super.displaceIfPossible(world, x, y, z); + public int getBlockColor() { + if (mRGB != null && mRGB.length >= 3) { + return Utils.rgbtoHexValue(mRGB[0], mRGB[1], mRGB[2]); + } + return super.getBlockColor(); } @Override - public int colorMultiplier(final IBlockAccess par1IBlockAccess, final int par2, final int par3, final int par4){ - - if (this.colour == 0){ - return MathUtils.generateSingularRandomHexValue(); - } - - return this.colour; + public int getRenderColor(int aMeta) { + if (mRGB != null && mRGB.length >= 3) { + return Utils.rgbtoHexValue(mRGB[0], mRGB[1], mRGB[2]); + } + return super.getRenderColor(aMeta); } @Override - public int getRenderColor(final int aMeta) { - if (this.colour == 0){ - return MathUtils.generateSingularRandomHexValue(); - } - - return this.colour; + public boolean recolourBlock(World world, int x, int y, int z, ForgeDirection side, int colour) { + // TODO Auto-generated method stub + return super.recolourBlock(world, x, y, z, side, colour); } - public String GetProperName() { - String tempIngot; - - tempIngot = "Molten "+this.displayName; - - return tempIngot; + @Override + public boolean canDisplace(IBlockAccess world, int x, int y, int z) { + if (world.getBlock(x, y, z).getMaterial().isLiquid()) { + return false; + } + return super.canDisplace(world, x, y, z); } - public Material getFluidMaterial(){ - return this.fluidMaterial; + @Override + public boolean displaceIfPossible(World world, int x, int y, int z) { + if (world.getBlock(x, y, z).getMaterial().isLiquid()) { + return false; + } + return super.displaceIfPossible(world, x, y, z); } } diff --git a/src/Java/gtPlusPlus/core/fluids/FactoryFluid.java b/src/Java/gtPlusPlus/core/fluids/FactoryFluid.java new file mode 100644 index 0000000000..3359f18f7d --- /dev/null +++ b/src/Java/gtPlusPlus/core/fluids/FactoryFluid.java @@ -0,0 +1,49 @@ +package gtPlusPlus.core.fluids; +import gregtech.api.GregTech_API; +import gtPlusPlus.core.lib.CORE; +import net.minecraft.block.Block; +import net.minecraft.item.EnumRarity; +import net.minecraftforge.fluids.Fluid; + +public class FactoryFluid extends Fluid implements Runnable { + + private final String mTextureName; + private final short[] mRGBa; + + public FactoryFluid(String fluidName, final short[] aRGBa) { + this(fluidName, null, Short.MIN_VALUE, Short.MIN_VALUE, Short.MIN_VALUE, Short.MIN_VALUE, false, EnumRarity.common, aRGBa); + } + + public FactoryFluid(String fluidName, int luminosity, int density, int temp, int viscosity, final short[] aRGBa) { + this(fluidName, null, luminosity, density, temp, viscosity, (density == Short.MIN_VALUE || density >= 0 ? false : true), EnumRarity.common, aRGBa); + } + + public FactoryFluid(String fluidName, Block aBlock, int luminosity, int density, int temp, int viscosity, boolean gas, EnumRarity aRarity, final short[] aRGBa) { + super(fluidName); + this.mRGBa = aRGBa; + this.setBlock(aBlock); + if (luminosity != Short.MIN_VALUE) + this.setLuminosity(luminosity); + if (density != Short.MIN_VALUE) + this.setDensity(density); + if (temp != Short.MIN_VALUE) + this.setTemperature(temp); + if (viscosity != Short.MIN_VALUE) + this.setViscosity(viscosity); + this.setGaseous(gas); + this.setRarity(aRarity); + this.mTextureName = CORE.MODID+":fluids/fluid.fluid.autogenerated"; + GregTech_API.sGTBlockIconload.add(this); + } + + @Override + public int getColor() { + return (Math.max(0, Math.min(255, this.mRGBa[0])) << 16) | (Math.max(0, Math.min(255, this.mRGBa[1])) << 8) | Math.max(0, Math.min(255, this.mRGBa[2])); + } + + @Override + public void run() { + this.setIcons(GregTech_API.sBlockIcons.registerIcon(CORE.MODID+ ":" + "fluids/fluid." + this.mTextureName)); + } + +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/core/fluids/FluidFactory.java b/src/Java/gtPlusPlus/core/fluids/FluidFactory.java new file mode 100644 index 0000000000..dffd7f55e9 --- /dev/null +++ b/src/Java/gtPlusPlus/core/fluids/FluidFactory.java @@ -0,0 +1,213 @@ +package gtPlusPlus.core.fluids; + +import java.util.LinkedHashMap; +import java.util.Map; + +import cpw.mods.fml.common.eventhandler.Event.Result; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import cpw.mods.fml.common.registry.GameRegistry; +import gtPlusPlus.GTplusplus; +import gtPlusPlus.GTplusplus.INIT_PHASE; +import gtPlusPlus.api.objects.GregtechException; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.item.base.itemblock.FluidItemBlock; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.world.World; +import net.minecraftforge.event.entity.player.FillBucketEvent; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidContainerRegistry; +import net.minecraftforge.fluids.FluidRegistry; + +public class FluidFactory { + + public static final Map<String, Fluid> mNameToFluidMap = new LinkedHashMap<String, Fluid>(); + public static final Map<String, ItemStack> mNameToBucketMap = new LinkedHashMap<String, ItemStack>(); + public static final Map<String, Block> mNameToBlockMap = new LinkedHashMap<String, Block>(); + public static final Map<String, Integer> mNameToMetaMap = new LinkedHashMap<String, Integer>(); + + public static final Map<Fluid, String> mFluidToNameMap = new LinkedHashMap<Fluid, String>(); + public static final Map<Fluid, ItemStack> mFluidToBucketMap = new LinkedHashMap<Fluid, ItemStack>(); + public static final Map<Fluid, Block> mFluidToBlockMap = new LinkedHashMap<Fluid, Block>(); + public static final Map<Fluid, Integer> mFluidToMetaMap = new LinkedHashMap<Fluid, Integer>(); + + public static final Map<ItemStack, Fluid> mBucketToFluidMap = new LinkedHashMap<ItemStack, Fluid>(); + public static final Map<ItemStack, String> mBucketToNameMap = new LinkedHashMap<ItemStack, String>(); + public static final Map<ItemStack, Block> mBucketToBlockMap = new LinkedHashMap<ItemStack, Block>(); + public static final Map<ItemStack, Integer> mBucketToMetaMap = new LinkedHashMap<ItemStack, Integer>(); + + public static final Map<Block, String> mBlockToNameMap = new LinkedHashMap<Block, String>(); + public static final Map<Block, Fluid> mBlockToFluidMap = new LinkedHashMap<Block, Fluid>(); + public static final Map<Block, ItemStack> mBlockToBucketMap = new LinkedHashMap<Block, ItemStack>(); + public static final Map<Block, Integer> mBlockToMetaMap = new LinkedHashMap<Block, Integer>(); + + public static final Map<Integer, String> mMetaToNameMap = new LinkedHashMap<Integer, String>(); + public static final Map<Integer, Fluid> mMetaToFluidMap = new LinkedHashMap<Integer, Fluid>(); + public static final Map<Integer, ItemStack> mMetaToBucketMap = new LinkedHashMap<Integer, ItemStack>(); + public static final Map<Integer, Block> mMetaToBlockMap = new LinkedHashMap<Integer, Block>(); + + + //Special Colour Handling + public static final Map<Integer, Integer> mMetaToColourMap = new LinkedHashMap<Integer, Integer>(); + + + public static Item mGenericBucket; + private static FluidPackage mErrorFluid; + private static AutoMap<FluidPackage> mGeneratedFluids = new AutoMap<FluidPackage>(); + + public static void preInit() { + + } + + public static void init() { + mGenericBucket = new ItemGenericFluidBucket(Blocks.air); + GameRegistry.registerItem(mGenericBucket, "gtpp.bucket.generic"); + for (FluidPackage y : mGeneratedFluids) { + if (!y.valid()) { + continue; + } + GameRegistry.registerBlock(y.mBlock, FluidItemBlock.class, "gtpp_" + y.mName); + FluidContainerRegistry.registerFluidContainer(y.get(), y.mBucket, new ItemStack(Items.bucket)); + } + Utils.registerEvent(BucketHandler.INSTANCE); + } + + public static void postInit() { + + } + + /** + * Generates a 'Water' type fluid. + * @param aID - The Fluid ID (Must be unique) + * @param aUnlocalName - Unlocalized Fluid Name + * @param aRGB - a {@link Short[]} containing the RGB of the FluidPackage. + * @return - A fully constructed & registered {@linkplain FluidPackage} + */ + public static FluidPackage generate(int aID, String aUnlocalName, short[] aRGB) { + return generate(aID, aUnlocalName, Short.MIN_VALUE, Short.MIN_VALUE, Short.MIN_VALUE, Short.MIN_VALUE, aRGB); + } + + /** + * Generate a {@link FluidPackage} from the data provided. This FluidPackage is automatically registered and handled internally. + * Pass in {@link Short}.MIN_VALUE for any of the Fluid Fields (Besides ID, Name or RGB) and it will default to water values. + * @param aID - The Fluid ID (Must be unique) + * @param aUnlocalName - Unlocalized Fluid Name + * @param luminosity - How bright is the fluid. + * @param density - completely arbitrary; negative density indicates that the fluid is + * lighter than air. Default value is approximately the real-life density of water in kg/m^3. + * @param temp - completely arbitrary; higher temperature indicates that the fluid is + * hotter than air. Default value is approximately the real-life room temperature of water in degrees Kelvin + * @param viscosity - completely arbitrary; negative values are not + * permissible. Default value is approximately the real-life density of water in m/s^2 (x10^-3). * + * Higher viscosity means that a fluid flows more slowly, like molasses. + * Lower viscosity means that a fluid flows more quickly, like helium. + * @param aRGB - a {@link Short[]} containing the RGB of the FluidPackage. + * @return - A fully constructed & registered {@linkplain FluidPackage} + */ + public static FluidPackage generate(int aID, String aUnlocalName, int luminosity, int density, int temp, + int viscosity, short[] aRGB) { + + FluidPackage aFluidToGenerate = null; + + // Check Load Phase for some Safety, only allow this to be called in Pre-Init. + if (GTplusplus.CURRENT_LOAD_PHASE != INIT_PHASE.PRE_INIT) { + try { + throw new GregtechException("Cannot generate Fluid Packages outside of Pre-Init!"); + } catch (GregtechException e) { + System.exit(0); + } + } + + Fluid aGenFluid = fluid(aUnlocalName, luminosity, density, temp, viscosity, aRGB); + Block aGenBlock = block(aGenFluid, aRGB); + ItemStack aGenBucket = bucket(aID); + + aFluidToGenerate = new FluidPackage(aID, aUnlocalName, aGenFluid, aGenBucket, aGenBlock); + + if (aFluidToGenerate != null && aFluidToGenerate.valid()) { + FluidRegistry.registerFluid(aFluidToGenerate.get()); + mGeneratedFluids.put(aFluidToGenerate); + } + else { + // Handle Bad generation + if (mErrorFluid == null) { + mErrorFluid = new FluidPackage(0, "", FluidUtils.getWater(1).getFluid(), ItemUtils.getSimpleStack(Items.water_bucket), Blocks.water); + } + return mErrorFluid; + } + + + return aFluidToGenerate; + } + + + + private static Fluid fluid(String aUnlocalName, int luminosity, int density, int temp, + int viscosity, short[] aRGB) { + return new FactoryFluid(aUnlocalName, luminosity, density, temp, viscosity, aRGB); + } + + private static ItemStack bucket(int aID) { + return ItemGenericFluidBucket.registerFluidForBucket(aID); + } + + private static Block block(Fluid aFluidForBlock, short[] aRGB) { + if (aFluidForBlock != null) { + FluidRegistry.registerFluid(aFluidForBlock); + return new BlockFluidBase(aFluidForBlock, aRGB); + } + return Blocks.dirt; + } + + /** + * Copyright © SpaceToad, 2011 http://www.mod-buildcraft.com BuildCraft is + * distributed under the terms of the Minecraft Mod Public License 1.0, or MMPL. + * Please check the contents of the license located in + * http://www.mod-buildcraft.com/MMPL-1.0.txt + * + * Modified version of the BC BucketHandler, except using ItemStacks > Items + * (Why?) + * + * @author Alkalus + */ + + public static class BucketHandler { + + public static BucketHandler INSTANCE = new BucketHandler(); + + private BucketHandler() { + + } + + @SubscribeEvent + public void onBucketFill(FillBucketEvent event) { + ItemStack result = fillCustomBucket(event.world, event.target); + if (result == null) { + return; + } + event.result = result; + event.setResult(Result.ALLOW); + } + + private ItemStack fillCustomBucket(World world, MovingObjectPosition pos) { + Block block = world.getBlock(pos.blockX, pos.blockY, pos.blockZ); + ItemStack bucket = mBlockToBucketMap.get(block); + if (bucket != null && world.getBlockMetadata(pos.blockX, pos.blockY, pos.blockZ) == 0) { + world.setBlockToAir(pos.blockX, pos.blockY, pos.blockZ); + return ItemUtils.getSimpleStack(bucket, 1); + } else { + return null; + } + } + + } + +} diff --git a/src/Java/gtPlusPlus/core/fluids/FluidPackage.java b/src/Java/gtPlusPlus/core/fluids/FluidPackage.java new file mode 100644 index 0000000000..29f831776b --- /dev/null +++ b/src/Java/gtPlusPlus/core/fluids/FluidPackage.java @@ -0,0 +1,83 @@ +package gtPlusPlus.core.fluids; + +import static gtPlusPlus.core.fluids.FluidFactory.mBlockToBucketMap; +import static gtPlusPlus.core.fluids.FluidFactory.mBlockToFluidMap; +import static gtPlusPlus.core.fluids.FluidFactory.mBlockToMetaMap; +import static gtPlusPlus.core.fluids.FluidFactory.mBlockToNameMap; +import static gtPlusPlus.core.fluids.FluidFactory.mBucketToBlockMap; +import static gtPlusPlus.core.fluids.FluidFactory.mBucketToFluidMap; +import static gtPlusPlus.core.fluids.FluidFactory.mBucketToMetaMap; +import static gtPlusPlus.core.fluids.FluidFactory.mBucketToNameMap; +import static gtPlusPlus.core.fluids.FluidFactory.mFluidToBlockMap; +import static gtPlusPlus.core.fluids.FluidFactory.mFluidToBucketMap; +import static gtPlusPlus.core.fluids.FluidFactory.mFluidToMetaMap; +import static gtPlusPlus.core.fluids.FluidFactory.mFluidToNameMap; +import static gtPlusPlus.core.fluids.FluidFactory.mMetaToBlockMap; +import static gtPlusPlus.core.fluids.FluidFactory.mMetaToBucketMap; +import static gtPlusPlus.core.fluids.FluidFactory.mMetaToColourMap; +import static gtPlusPlus.core.fluids.FluidFactory.mMetaToFluidMap; +import static gtPlusPlus.core.fluids.FluidFactory.mMetaToNameMap; +import static gtPlusPlus.core.fluids.FluidFactory.mNameToBlockMap; +import static gtPlusPlus.core.fluids.FluidFactory.mNameToBucketMap; +import static gtPlusPlus.core.fluids.FluidFactory.mNameToFluidMap; +import static gtPlusPlus.core.fluids.FluidFactory.mNameToMetaMap; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; + +public class FluidPackage { + + + public final int mID; + public final String mName; + private final Fluid mFluid; + public final ItemStack mBucket; + public final Block mBlock; + + public FluidPackage(int aID, String aName, Fluid aFluid, ItemStack aBucket, Block aBlock) { + + mNameToFluidMap.put(aName, aFluid); + mNameToBucketMap.put(aName, aBucket); + mNameToBlockMap.put(aName, aBlock); + mNameToMetaMap.put(aName, aID); + + mFluidToNameMap.put(aFluid, aName); + mFluidToBucketMap.put(aFluid, aBucket); + mFluidToBlockMap.put(aFluid, aBlock); + mFluidToMetaMap.put(aFluid, aID); + + mBucketToFluidMap.put(aBucket, aFluid); + mBucketToNameMap.put(aBucket, aName); + mBucketToBlockMap.put(aBucket, aBlock); + mBucketToMetaMap.put(aBucket, aID); + + mBlockToNameMap.put(aBlock, aName); + mBlockToFluidMap.put(aBlock, aFluid); + mBlockToBucketMap.put(aBlock, aBucket); + mBlockToMetaMap.put(aBlock, aID); + + mMetaToNameMap.put(aID, aName); + mMetaToFluidMap.put(aID, aFluid); + mMetaToBucketMap.put(aID, aBucket); + mMetaToBlockMap.put(aID, aBlock); + + mMetaToColourMap.put(aID, aFluid.getColor()); + + mID = aID; + mName = aName; + mFluid = aFluid; + mBucket = aBucket; + mBlock = aBlock; + + } + + public Fluid get() { + return mFluid; + } + + public boolean valid() { + return mName != null && mName.length() > 0 && mFluid != null && mBucket != null && mBlock != null; + } + +} diff --git a/src/Java/gtPlusPlus/core/fluids/GenericFluid.java b/src/Java/gtPlusPlus/core/fluids/GenericFluid.java deleted file mode 100644 index 4f1f5df006..0000000000 --- a/src/Java/gtPlusPlus/core/fluids/GenericFluid.java +++ /dev/null @@ -1,70 +0,0 @@ -package gtPlusPlus.core.fluids; - -import cpw.mods.fml.common.registry.GameRegistry; - -import net.minecraft.block.Block; - -import gtPlusPlus.core.item.base.itemblock.ItemBlockFluid; -import gtPlusPlus.core.material.Material; -import net.minecraftforge.fluids.Fluid; -import net.minecraftforge.fluids.FluidRegistry; - -public class GenericFluid extends Fluid{ - - protected final String fluidName; - protected final Fluid fluidFactory; - protected final Block blockFactory; - protected final short[] rgba; - - public GenericFluid(final String displayName, final String fluidName, final int luminosity, final int density, final int temperature, final int viscosity, final boolean isGas, final short[] rgba) { - super(fluidName); - this.fluidFactory = this; - this.rgba = rgba; - this.fluidName = fluidName; - this.fluidFactory.setLuminosity(luminosity); - this.fluidFactory.setDensity(density); - this.fluidFactory.setTemperature(temperature); - this.fluidFactory.setViscosity(viscosity); - this.fluidFactory.setGaseous(isGas); - this.fluidFactory.setUnlocalizedName("fluid"+fluidName); - FluidRegistry.registerFluid(this.fluidFactory); - this.blockFactory = new BlockFluidBase(displayName, this.fluidFactory, rgba).setBlockName("fluidblock"+fluidName); - GameRegistry.registerBlock(this.blockFactory, ItemBlockFluid.class, this.blockFactory.getUnlocalizedName().substring(5)); - this.fluidFactory.setBlock(this.blockFactory); - - //fluidFactory.setUnlocalizedName(blockFactory.getUnlocalizedName()); - - } - - public GenericFluid(final Material fluidMaterial, final int luminosity, final int density, final int temperature, final int viscosity, final boolean isGas) { - - super(fluidMaterial.getUnlocalizedName()); - //IC2_ItemFluidCell fullFluidCell = emptyCell.fill(emptyCell, FluidUtils.getFluidStack(getUnlocalizedName(), 1), true); - - this.fluidFactory = this; - this.rgba = fluidMaterial.getRGBA(); - this.fluidName = fluidMaterial.getUnlocalizedName(); - this.fluidFactory.setLuminosity(luminosity); - this.fluidFactory.setDensity(density); - this.fluidFactory.setTemperature(temperature); - this.fluidFactory.setViscosity(viscosity); - this.fluidFactory.setGaseous(isGas); - this.fluidFactory.setUnlocalizedName("fluid"+this.fluidName); - FluidRegistry.registerFluid(this.fluidFactory); - this.blockFactory = new BlockFluidBase(this.fluidFactory, fluidMaterial).setBlockName("fluidblock"+this.fluidName); - GameRegistry.registerBlock(this.blockFactory, ItemBlockFluid.class, this.blockFactory.getUnlocalizedName().substring(5)); - this.fluidFactory.setBlock(this.blockFactory); - //IC2_ItemFluidCell emptyCell = new IC2_ItemFluidCell(fluidName); - /*if (aFullContainer != null && aEmptyContainer != null && !FluidContainerRegistry.registerFluidContainer(new FluidStack(rFluid, aFluidAmount), aFullContainer, aEmptyContainer)) { - GT_Values.RA.addFluidCannerRecipe(aFullContainer, container(aFullContainer, false), null, new FluidStack(rFluid, aFluidAmount)); - }*/ - //fluidFactory.setUnlocalizedName(blockFactory.getUnlocalizedName()); - - } - - @Override - public int getColor() { - return (Math.max(0, Math.min(255, this.rgba[0])) << 16) | (Math.max(0, Math.min(255, this.rgba[1])) << 8) | Math.max(0, Math.min(255, this.rgba[2])); - } - -} diff --git a/src/Java/gtPlusPlus/core/fluids/ItemGenericFluidBucket.java b/src/Java/gtPlusPlus/core/fluids/ItemGenericFluidBucket.java new file mode 100644 index 0000000000..d41fccb3ed --- /dev/null +++ b/src/Java/gtPlusPlus/core/fluids/ItemGenericFluidBucket.java @@ -0,0 +1,318 @@ +package gtPlusPlus.core.fluids; + +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import cpw.mods.fml.common.eventhandler.Event; +import gtPlusPlus.api.objects.GregtechException; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemBucket; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.world.World; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.entity.player.FillBucketEvent; + +public class ItemGenericFluidBucket extends ItemBucket { + + private static IIcon mBaseBucketTexture; + private static IIcon mOverlayBucketTexture; + private static AutoMap<Block> mInternalFluidCache = new AutoMap<Block>(); + + public ItemGenericFluidBucket(Block aFluid) { + super(aFluid); + this.setContainerItem(Items.bucket); + this.maxStackSize = 1; + mInternalFluidCache.put(aFluid); + } + + public static ItemStack registerFluidForBucket(int aID) { + + if (FluidFactory.mMetaToBucketMap.containsKey(aID)) { + try { + throw new GregtechException(""+aID+" is already registered! Unable to register fluid: "+FluidFactory.mMetaToFluidMap.get(aID).getLocalizedName()); + } catch (GregtechException e) { + System.exit(0); + } + } + mInternalFluidCache.put(FluidFactory.mMetaToBlockMap.get(aID)); + return ItemUtils.simpleMetaStack(FluidFactory.mGenericBucket, aID, 1); + } + + Map<Integer, IIcon> mIconCache = new LinkedHashMap<Integer, IIcon>(); + + /** + * Called whenever this item is equipped and the right mouse button is pressed. + * Args: itemStack, world, entityPlayer + */ + public ItemStack onItemRightClick(ItemStack aStack, World aWorld, EntityPlayer aPlayer) { + + Block isFull = FluidFactory.mMetaToBlockMap.get(aStack.getItemDamage()); + + boolean flag = isFull == Blocks.air; + MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(aWorld, aPlayer, flag); + + if (movingobjectposition == null || isFull == null) { + return aStack; + } else { + FillBucketEvent event = new FillBucketEvent(aPlayer, aStack, aWorld, movingobjectposition); + if (MinecraftForge.EVENT_BUS.post(event)) { + return aStack; + } + + if (event.getResult() == Event.Result.ALLOW) { + if (aPlayer.capabilities.isCreativeMode) { + return aStack; + } + + if (--aStack.stackSize <= 0) { + return event.result; + } + + if (!aPlayer.inventory.addItemStackToInventory(event.result)) { + aPlayer.dropPlayerItemWithRandomChoice(event.result, false); + } + + return aStack; + } + if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK) { + int i = movingobjectposition.blockX; + int j = movingobjectposition.blockY; + int k = movingobjectposition.blockZ; + + if (!aWorld.canMineBlock(aPlayer, i, j, k)) { + return aStack; + } + + if (flag) { + if (!aPlayer.canPlayerEdit(i, j, k, movingobjectposition.sideHit, aStack)) { + return aStack; + } + + Material material = aWorld.getBlock(i, j, k).getMaterial(); + int l = aWorld.getBlockMetadata(i, j, k); + + if (material == Material.water && l == 0) { + aWorld.setBlockToAir(i, j, k); + return this.func_150910_a(aStack, aPlayer, Items.water_bucket); + } + + if (material == Material.lava && l == 0) { + aWorld.setBlockToAir(i, j, k); + return this.func_150910_a(aStack, aPlayer, Items.lava_bucket); + } + } else { + if (isFull == Blocks.air) { + return new ItemStack(Items.bucket); + } + + if (movingobjectposition.sideHit == 0) { + --j; + } + + if (movingobjectposition.sideHit == 1) { + ++j; + } + + if (movingobjectposition.sideHit == 2) { + --k; + } + + if (movingobjectposition.sideHit == 3) { + ++k; + } + + if (movingobjectposition.sideHit == 4) { + --i; + } + + if (movingobjectposition.sideHit == 5) { + ++i; + } + + if (!aPlayer.canPlayerEdit(i, j, k, movingobjectposition.sideHit, aStack)) { + return aStack; + } + + if (this.tryPlaceContainedLiquid(isFull, aWorld, i, j, k) && !aPlayer.capabilities.isCreativeMode) { + return new ItemStack(Items.bucket); + } + } + } + + return aStack; + } + } + + private ItemStack func_150910_a(ItemStack p_150910_1_, EntityPlayer p_150910_2_, Item p_150910_3_) { + if (p_150910_2_.capabilities.isCreativeMode) { + return p_150910_1_; + } else if (--p_150910_1_.stackSize <= 0) { + return new ItemStack(p_150910_3_); + } else { + if (!p_150910_2_.inventory.addItemStackToInventory(new ItemStack(p_150910_3_))) { + p_150910_2_.dropPlayerItemWithRandomChoice(new ItemStack(p_150910_3_, 1, 0), false); + } + + return p_150910_1_; + } + } + + /** + * Attempts to place the liquid contained inside the bucket. + */ + public boolean tryPlaceContainedLiquid(Block isFull, World aWorld, int aX, int aY, int aZ) { + if (isFull == Blocks.air) { + return false; + } else { + Material material = aWorld.getBlock(aX, aY, aZ).getMaterial(); + boolean flag = !material.isSolid(); + + if (!aWorld.isAirBlock(aX, aY, aZ) && !flag) { + return false; + } else { + + if (!aWorld.isRemote && flag && !material.isLiquid()) { + aWorld.func_147480_a(aX, aY, aZ, true); + } + + aWorld.setBlock(aX, aY, aZ, isFull, 0, 3); + + return true; + } + } + } + + @Override + public IIcon getIconFromDamage(int aMeta) { + IIcon aTemp = mIconCache.get(aMeta); + return aTemp != null ? aTemp : super.getIconFromDamage(aMeta); + } + + @Override + public boolean getHasSubtypes() { + return mInternalFluidCache.size() > 0; + } + + @Override + public void getSubItems(Item item, CreativeTabs tab, List list) { + list.add(new ItemStack(item, 1, 0)); + for (Block f : mInternalFluidCache) { + Integer aMeta; + if (f != null) { + aMeta = FluidFactory.mBlockToMetaMap.get(f); + if (aMeta != null) { + list.add(new ItemStack(item, 1, aMeta)); + } + } + } + } + + @Override + public int getMaxDamage() { + return 512; + } + + @Override + public boolean isDamageable() { + return false; + } + + @Override + public void addInformation(ItemStack p_77624_1_, EntityPlayer p_77624_2_, List p_77624_3_, boolean p_77624_4_) { + // TODO Auto-generated method stub + super.addInformation(p_77624_1_, p_77624_2_, p_77624_3_, p_77624_4_); + } + + @Override + public int getItemEnchantability() { + return 0; + } + + @Override + public boolean isRepairable() { + return false; + } + + @Override + public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining) { + if (stack != null && renderPass == 1) { + return mOverlayBucketTexture; + } + else { + return mBaseBucketTexture; + } + /*IIcon aTemp = mIconCache.get(stack.getItemDamage()); + return aTemp != null ? aTemp : super.getIcon(stack, renderPass, player, usingItem, useRemaining);*/ + } + + @Override + public boolean isBookEnchantable(ItemStack stack, ItemStack book) { + return false; + } + + @Override + public int getMaxDamage(ItemStack stack) { + return 512; + } + + @Override + public boolean isDamaged(ItemStack stack) { + return false; + } + + @Override + public int getItemEnchantability(ItemStack stack) { + return 0; + } + + @Override + public IIcon getIconFromDamageForRenderPass(final int damage, final int pass) { + if (pass == 1) { + return mOverlayBucketTexture; + } + else { + return mBaseBucketTexture; + } + } + + @Override + public void registerIcons(final IIconRegister i) { + mBaseBucketTexture = i.registerIcon("bucket_empty"); + mOverlayBucketTexture = i.registerIcon(CORE.MODID+":bucket.generic.overlay"); + } + + @Override + public boolean tryPlaceContainedLiquid(World p_77875_1_, int p_77875_2_, int p_77875_3_, int p_77875_4_) { + return tryPlaceContainedLiquid(Blocks.air, p_77875_1_, p_77875_2_, p_77875_3_, p_77875_4_); + } + + @Override + public int getColorFromItemStack(ItemStack aStack, int aPass) { + if (aPass == 0) { + return super.getColorFromItemStack(aStack, aPass); + } + else { + return FluidFactory.mMetaToColourMap.get(aStack.getItemDamage()); + } + } + + @Override + public boolean requiresMultipleRenderPasses() { + return true; + } + + +} diff --git a/src/Java/gtPlusPlus/core/handler/AchievementHandler.java b/src/Java/gtPlusPlus/core/handler/AchievementHandler.java index faca4449ce..482ca66f09 100644 --- a/src/Java/gtPlusPlus/core/handler/AchievementHandler.java +++ b/src/Java/gtPlusPlus/core/handler/AchievementHandler.java @@ -18,6 +18,7 @@ import gtPlusPlus.core.material.ALLOY; import gtPlusPlus.core.material.ELEMENT; import gtPlusPlus.core.util.minecraft.ItemUtils; import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; +import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.stats.Achievement; @@ -46,7 +47,7 @@ public class AchievementHandler { //Useful Info boolean cores = CORE.ConfigSwitches.requireControlCores; - if (cores) { + if (cores || GregtechMeta_MultiBlockBase.DEBUG_DISABLE_CORES_TEMPORARILY) { this.registerAchievement("hatch.control", -2, -2, GregtechItemList.Hatch_Control_Core.get(1), aBaseAchievementName, false); } this.registerAchievement("hatch.dynamo.buffered", 2, -2, GregtechItemList.Hatch_Buffer_Dynamo_IV.get(1), aBaseAchievementName, false); diff --git a/src/Java/gtPlusPlus/core/handler/COMPAT_HANDLER.java b/src/Java/gtPlusPlus/core/handler/COMPAT_HANDLER.java index f6735de8e4..1e3cb0ffbb 100644 --- a/src/Java/gtPlusPlus/core/handler/COMPAT_HANDLER.java +++ b/src/Java/gtPlusPlus/core/handler/COMPAT_HANDLER.java @@ -4,11 +4,13 @@ import static gtPlusPlus.core.lib.LoadedMods.Gregtech; import java.util.*; +import cpw.mods.fml.common.event.FMLLoadCompleteEvent; import gregtech.api.enums.GT_Values; import gregtech.api.util.GT_OreDictUnificator; import gtPlusPlus.api.interfaces.RunnableWithInfo; import gtPlusPlus.api.objects.Logger; import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.api.objects.minecraft.ItemPackage; import gtPlusPlus.core.common.compat.*; import gtPlusPlus.core.handler.Recipes.LateRegistrationHandler; import gtPlusPlus.core.handler.Recipes.RegistrationHandler; @@ -19,6 +21,7 @@ import gtPlusPlus.core.material.MaterialGenerator; import gtPlusPlus.core.recipe.*; import gtPlusPlus.core.util.minecraft.ItemUtils; import gtPlusPlus.core.util.minecraft.RecipeUtils; +import gtPlusPlus.xmod.gregtech.HANDLER_GT; import gtPlusPlus.xmod.gregtech.loaders.RecipeGen_Recycling; import gtPlusPlus.xmod.gregtech.registration.gregtech.*; import net.minecraft.item.ItemStack; @@ -39,7 +42,7 @@ public class COMPAT_HANDLER { GT_OreDictUnificator.registerOre("craftingToolSandHammer", new ItemStack(ModItems.itemSandstoneHammer)); for(int i=1; i<=10; i++){ - GT_OreDictUnificator.registerOre("bufferCore_"+GT_Values.VN[i-1], new ItemStack(ItemUtils.getItem("miscutils:item.itemBufferCore"+i))); + GT_OreDictUnificator.registerOre("bufferCore_"+GT_Values.VN[i-1], new ItemStack(ItemUtils.getItemFromFQRN("miscutils:item.itemBufferCore"+i))); } } @@ -204,11 +207,21 @@ public class COMPAT_HANDLER { } } } - RecipeGen_Recycling.executeGenerators(); + RecipeGen_Recycling.executeGenerators(); + runQueuedMisc(); + } + + + + public static void onLoadComplete(FMLLoadCompleteEvent event) { + runQueuedOnLoadComplete(event); } public static final AutoMap<RunnableWithInfo<String>> mRecipesToGenerate = new AutoMap<RunnableWithInfo<String>>(); - public static final AutoMap<RunnableWithInfo<String>> mGtRecipesToGenerate = new AutoMap<RunnableWithInfo<String>>(); + public static final AutoMap<RunnableWithInfo<String>> mGtRecipesToGenerate = new AutoMap<RunnableWithInfo<String>>(); + + public static final AutoMap<RunnableWithInfo<String>> mObjectsToRunInPostInit = new AutoMap<RunnableWithInfo<String>>(); + public static final AutoMap<ItemPackage> mObjectsToRunInOnLoadComplete = new AutoMap<ItemPackage>(); public static void runQueuedRecipes() { //Add autogenerated Recipes from Item Components @@ -233,4 +246,33 @@ public class COMPAT_HANDLER { } } + + public static void runQueuedMisc() { + for (RunnableWithInfo<String> m : mObjectsToRunInPostInit) { + try { + m.run(); + } + catch (Throwable t) { + t.printStackTrace(); + Logger.INFO("[ERROR] "+m.getInfoData()); + } + + } + } + + /** + * Generally used to register GT recipe map changes after they've been populated. + */ + public static void runQueuedOnLoadComplete(FMLLoadCompleteEvent event) { + for (ItemPackage m : mObjectsToRunInOnLoadComplete) { + try { + m.onLoadComplete(event); + } + catch (Throwable t) { + t.printStackTrace(); + Logger.INFO("[ERROR] "+m.getInfoData()); + } + + } + } } diff --git a/src/Java/gtPlusPlus/core/handler/events/GeneralTooltipEventHandler.java b/src/Java/gtPlusPlus/core/handler/events/GeneralTooltipEventHandler.java index 6d09f65f3f..ef91647c1a 100644 --- a/src/Java/gtPlusPlus/core/handler/events/GeneralTooltipEventHandler.java +++ b/src/Java/gtPlusPlus/core/handler/events/GeneralTooltipEventHandler.java @@ -3,12 +3,16 @@ package gtPlusPlus.core.handler.events; import cpw.mods.fml.common.eventhandler.SubscribeEvent; import net.minecraft.block.Block; +import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumChatFormatting; import gregtech.api.enums.ItemList; +import gregtech.api.util.GT_Utility; import gtPlusPlus.GTplusplus; import gtPlusPlus.GTplusplus.INIT_PHASE; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.block.ModBlocks; import gtPlusPlus.core.handler.events.BlockEventHandler; import gtPlusPlus.core.lib.CORE; import gtPlusPlus.core.util.minecraft.ItemUtils; @@ -25,10 +29,12 @@ public class GeneralTooltipEventHandler { public void onItemTooltip(ItemTooltipEvent event){ - if (GTplusplus.CURRENT_LOAD_PHASE != INIT_PHASE.STARTED) { + if (GTplusplus.CURRENT_LOAD_PHASE != INIT_PHASE.STARTED && GTplusplus.CURRENT_LOAD_PHASE != INIT_PHASE.SERVER_START) { + return; + } + if (event.itemStack == null) { return; } - if (CORE.ConfigSwitches.chanceToDropFluoriteOre > 0) { if (BlockEventHandler.blockLimestone != null && !BlockEventHandler.blockLimestone.isEmpty()) { for (ItemStack h : BlockEventHandler.blockLimestone) { @@ -50,6 +56,26 @@ public class GeneralTooltipEventHandler { } } + //Material Collector Tooltips + if (ModBlocks.blockPooCollector != null && Block.getBlockFromItem(event.itemStack.getItem()) == ModBlocks.blockPooCollector) { + //Normal + if (event.itemStack.getItemDamage() == 0) { + event.toolTip.add("Used to collect animal waste"); + event.toolTip.add("Collects in a 5x4x5 area starting at Y+1"); + event.toolTip.add("Use Hoppers/Pipes to empty"); + event.toolTip.add(EnumChatFormatting.GOLD+"Capacity: "+EnumChatFormatting.AQUA+"8000L"); + } + //Advanced + else { + event.toolTip.add("Used to collect waste (Works on more than animals)"); + event.toolTip.add("Significantly faster than the simple version"); + event.toolTip.add("Collects in a 5x4x5 area starting at Y+1"); + event.toolTip.add("Use Hoppers/Pipes to empty"); + event.toolTip.add(EnumChatFormatting.GOLD+"Capacity: "+EnumChatFormatting.AQUA+"128000L"); + } + } + + if (CORE.ConfigSwitches.enableAnimatedTurbines) { boolean shift = false; diff --git a/src/Java/gtPlusPlus/core/item/ModItems.java b/src/Java/gtPlusPlus/core/item/ModItems.java index 8057f6bbe1..e8f0e31458 100644 --- a/src/Java/gtPlusPlus/core/item/ModItems.java +++ b/src/Java/gtPlusPlus/core/item/ModItems.java @@ -32,7 +32,9 @@ import gtPlusPlus.core.item.base.plates.BaseItemPlateDouble; import gtPlusPlus.core.item.bauble.BatteryPackBaseBauble; import gtPlusPlus.core.item.bauble.HealthBoostBauble; import gtPlusPlus.core.item.bauble.ModularBauble; +import gtPlusPlus.core.item.chemistry.AgriculturalChem; import gtPlusPlus.core.item.chemistry.CoalTar; +import gtPlusPlus.core.item.chemistry.GenericChem; import gtPlusPlus.core.item.chemistry.IonParticles; import gtPlusPlus.core.item.chemistry.NuclearChem; import gtPlusPlus.core.item.chemistry.RocketFuels; @@ -60,6 +62,7 @@ import gtPlusPlus.core.item.general.chassis.ItemDehydratorCoil; import gtPlusPlus.core.item.general.chassis.ItemDehydratorCoilWire; import gtPlusPlus.core.item.general.throwables.ItemHydrofluoricAcidPotion; import gtPlusPlus.core.item.general.throwables.ItemSulfuricAcidPotion; +import gtPlusPlus.core.item.general.throwables.ItemThrowableBomb; import gtPlusPlus.core.item.init.ItemsFoods; import gtPlusPlus.core.item.materials.DustDecayable; import gtPlusPlus.core.item.tool.misc.DebugScanner; @@ -337,6 +340,11 @@ public final class ModItems { public static ItemDummyResearch itemDummyResearch; + public static CoreItem itemBombCasing; + public static CoreItem itemBombUnf; + public static CoreItem itemDetCable; + public static ItemThrowableBomb itemBomb; + static { Logger.INFO("Items!"); //Default item used when recipes fail, handy for debugging. Let's make sure they exist when this class is called upon. @@ -366,7 +374,7 @@ public final class ModItems { //Some Simple forms of materials itemStickyRubber = new Item().setUnlocalizedName("itemStickyRubber").setCreativeTab(tabMachines).setTextureName(CORE.MODID + ":itemStickyRubber"); GameRegistry.registerItem(itemStickyRubber, "itemStickyRubber"); - GT_OreDictUnificator.registerOre("ingotRubber", ItemUtils.getItemStack(CORE.MODID+":itemStickyRubber", 1)); + GT_OreDictUnificator.registerOre("ingotRubber", ItemUtils.getItemStackFromFQRN(CORE.MODID+":itemStickyRubber", 1)); itemCoalCoke = new BaseItemBurnable("itemCoalCoke", "Coking Coal", tabMisc, 64, 0, "Used for metallurgy.", "fuelCoke", 3200, 0).setTextureName(CORE.MODID + ":itemCoalCoke"); @@ -879,12 +887,28 @@ public final class ModItems { itemControlCore = new ItemControlCore(); //Chemistry - CoalTar.run(); - RocketFuels.run(); + new CoalTar(); + new RocketFuels(); //Nuclear Processing - NuclearChem.run(); - + new NuclearChem(); + + //Farm Animal Fun + new AgriculturalChem(); + + //General Chemistry + new GenericChem(); + + + //Bombs + itemBombCasing = new CoreItem("itemBombCasing", "Bomb Casing", tabMisc); + itemBombCasing.setTextureName(CORE.MODID + ":bomb_casing"); + itemBombUnf = new CoreItem("itemBombUnf", "Bomb (unf)", tabMisc); + itemBombUnf.setTextureName(CORE.MODID + ":bomb_casing"); + itemDetCable = new CoreItem("itemDetCable", "Det. Cable", tabMisc); + itemDetCable.setTextureName("string"); + itemBomb = new ItemThrowableBomb(); + //Only used for debugging. /*if (CORE.DEVENV) { new ConnectedBlockFinder(); diff --git a/src/Java/gtPlusPlus/core/item/base/BaseItemComponent.java b/src/Java/gtPlusPlus/core/item/base/BaseItemComponent.java index 522b7e900e..ceeff7e655 100644 --- a/src/Java/gtPlusPlus/core/item/base/BaseItemComponent.java +++ b/src/Java/gtPlusPlus/core/item/base/BaseItemComponent.java @@ -18,6 +18,7 @@ import gtPlusPlus.core.lib.LoadedMods; import gtPlusPlus.core.material.Material; import gtPlusPlus.core.material.state.MaterialState; import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.data.StringUtils; import gtPlusPlus.core.util.math.MathUtils; import gtPlusPlus.core.util.minecraft.EntityUtils; import gtPlusPlus.core.util.minecraft.ItemUtils; @@ -77,18 +78,28 @@ public class BaseItemComponent extends Item{ //For Cell Generation public BaseItemComponent(final String unlocalName, final String localName, final short[] RGBA) { + + // Handles .'s from fluid internal names. + String aFormattedNameForFluids; + if (unlocalName.contains(".")) { + aFormattedNameForFluids = StringUtils.splitAndUppercase(unlocalName, "."); + } + else { + aFormattedNameForFluids = unlocalName; + } + this.componentMaterial = null; - this.unlocalName = "itemCell"+unlocalName; + this.unlocalName = "itemCell"+aFormattedNameForFluids; this.materialName = localName; this.componentType = ComponentTypes.CELL; this.setCreativeTab(AddToCreativeTab.tabMisc); - this.setUnlocalizedName(unlocalName); + this.setUnlocalizedName(aFormattedNameForFluids); this.setMaxStackSize(64); this.componentColour = MathUtils.getRgbAsHex(RGBA); this.extraData = RGBA; this.setTextureName(CORE.MODID + ":" + "item"+ComponentTypes.CELL.COMPONENT_NAME); - GameRegistry.registerItem(this, unlocalName); - GT_OreDictUnificator.registerOre(ComponentTypes.CELL.getOreDictName()+unlocalName, ItemUtils.getSimpleStack(this)); + GameRegistry.registerItem(this, aFormattedNameForFluids); + GT_OreDictUnificator.registerOre(ComponentTypes.CELL.getOreDictName()+aFormattedNameForFluids, ItemUtils.getSimpleStack(this)); registerComponent(); } diff --git a/src/Java/gtPlusPlus/core/item/base/itemblock/ItemBlockFluid.java b/src/Java/gtPlusPlus/core/item/base/itemblock/FluidItemBlock.java index 84fae41bb0..96b5425437 100644 --- a/src/Java/gtPlusPlus/core/item/base/itemblock/ItemBlockFluid.java +++ b/src/Java/gtPlusPlus/core/item/base/itemblock/FluidItemBlock.java @@ -13,38 +13,30 @@ import gtPlusPlus.core.material.Material; import gtPlusPlus.core.util.math.MathUtils; import gtPlusPlus.core.util.minecraft.ItemUtils; -public class ItemBlockFluid extends ItemBlock{ +public class FluidItemBlock extends ItemBlock{ protected final int blockColour; - protected final int sRadiation; - protected Material thisFluid; final BlockFluidBase baseBlock; String name; - public ItemBlockFluid(final Block block) { + public FluidItemBlock(final Block block) { super(block); this.baseBlock = (BlockFluidBase) block; this.blockColour = this.baseBlock.getRenderColor(1); - this.thisFluid = this.baseBlock.getFluidMaterial(); - this.sRadiation=ItemUtils.getRadioactivityLevel(this.baseBlock.getUnlocalizedName()); this.name = this.baseBlock.getLocalizedName().replace("tile", "").replace("fluid", "").replace("name", "").replace("block", "").replace(".", ""); //GT_OreDictUnificator.registerOre("frameGt"+block.getUnlocalizedName().replace("tile.", "").replace("tile.BlockGtFrame", "").replace("-", "").replace("_", "").replace(" ", "").replace("FrameBox", ""), UtilsItems.getSimpleStack(this)); } - public final Material setFluidMaterial(final Material M){ - return this.thisFluid=M; - } - public int getRenderColor(final int aMeta) { return this.blockColour; } @Override public String getItemStackDisplayName(final ItemStack iStack) { - if (this.thisFluid != null){ + /*if (this.thisFluid != null){ this.name = "Molten "+this.thisFluid.getLocalizedName(); return this.name; - } + }*/ this.name = "Molten "+this.baseBlock.getLocalizedName().replace("tile", "").replace("fluid", "").replace("name", "").replace("block", "").replace(".", ""); return this.name; } @@ -55,24 +47,15 @@ public class ItemBlockFluid extends ItemBlock{ return MathUtils.generateSingularRandomHexValue(); } return this.blockColour; - } @Override public void addInformation(final ItemStack stack, final EntityPlayer aPlayer, final List list, final boolean bool) { - list.add("Temperature: "+MathUtils.celsiusToKelvin(this.thisFluid.getMeltingPointC())+"K"); + /*list.add("Temperature: "+MathUtils.celsiusToKelvin(this.thisFluid.getMeltingPointC())+"K"); if (this.sRadiation > 0){ list.add(CORE.GT_Tooltip_Radioactive); - } + }*/ super.addInformation(stack, aPlayer, list, bool); } - public String GetProperName() { - String tempIngot; - - tempIngot = "Molten "+this.baseBlock.getLocalizedName(); - - return tempIngot; - } - } diff --git a/src/Java/gtPlusPlus/core/item/base/itemblock/ItemBlockMeta.java b/src/Java/gtPlusPlus/core/item/base/itemblock/ItemBlockMeta.java index 1d48bbbbf9..b26ac67225 100644 --- a/src/Java/gtPlusPlus/core/item/base/itemblock/ItemBlockMeta.java +++ b/src/Java/gtPlusPlus/core/item/base/itemblock/ItemBlockMeta.java @@ -1,8 +1,14 @@ package gtPlusPlus.core.item.base.itemblock; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; + import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; - +import gtPlusPlus.api.interfaces.ITileTooltip; +import gtPlusPlus.api.objects.data.AutoMap; import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemBlockWithMetadata; import net.minecraft.item.ItemStack; import net.minecraft.util.IIcon; @@ -10,13 +16,36 @@ import net.minecraft.util.IIcon; public class ItemBlockMeta extends ItemBlockWithMetadata { private final Block mBlock; + private HashMap<Integer, AutoMap<String>> aTooltips = new LinkedHashMap<Integer, AutoMap<String>>(); - public ItemBlockMeta(final Block p_i45326_1_) + public ItemBlockMeta(final Block aBlock) { - super(p_i45326_1_, p_i45326_1_); - this.mBlock = p_i45326_1_; + super(aBlock, aBlock); + this.mBlock = aBlock; this.setMaxDamage(0); this.setHasSubtypes(true); + if (aBlock instanceof ITileTooltip) { + ITileTooltip aTooltip = (ITileTooltip) aBlock; + //aTooltips.put(aTooltip.getTooltipID(), aTooltip.getTooltipMap()); + } + } + + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Override + public void addInformation(final ItemStack stack, final EntityPlayer aPlayer, final List list, final boolean bool) { + Block aThis = Block.getBlockFromItem(stack.getItem()); + if (aThis != null) { + if (!aTooltips.isEmpty()) { + AutoMap<String> h = aTooltips.get(stack.getItemDamage()); + if (h != null && !h.isEmpty()) { + for (String s : h) { + list.add(s); + } + } + } + } + super.addInformation(stack, aPlayer, list, bool); } /** @@ -42,4 +71,44 @@ public class ItemBlockMeta extends ItemBlockWithMetadata public String getUnlocalizedName(final ItemStack stack) { return this.getUnlocalizedName() + "." + stack.getItemDamage(); } + + @Override + public boolean isDamageable() { + return false; + } + + @Override + public int getItemEnchantability() { + return 0; + } + + @Override + public boolean getIsRepairable(ItemStack p_82789_1_, ItemStack p_82789_2_) { + return false; + } + + @Override + public boolean isBookEnchantable(ItemStack stack, ItemStack book) { + return false; + } + + @Override + public int getDisplayDamage(ItemStack stack) { + return 0; + } + + @Override + public boolean showDurabilityBar(ItemStack stack) { + return false; + } + + @Override + public double getDurabilityForDisplay(ItemStack stack) { + return 0; + } + + @Override + public int getItemEnchantability(ItemStack stack) { + return 0; + } }
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/core/item/chemistry/AgriculturalChem.java b/src/Java/gtPlusPlus/core/item/chemistry/AgriculturalChem.java new file mode 100644 index 0000000000..0c2bdaa3ef --- /dev/null +++ b/src/Java/gtPlusPlus/core/item/chemistry/AgriculturalChem.java @@ -0,0 +1,408 @@ +package gtPlusPlus.core.item.chemistry; + +import java.util.ArrayList; + +import forestry.plugins.PluginCore; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.api.objects.minecraft.ItemPackage; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.lib.LoadedMods; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; + +public class AgriculturalChem extends ItemPackage { + + private static boolean aBOP; + private static boolean aTiCon; + + private static AutoMap<FluidStack> mBloodFluids = new AutoMap<FluidStack>(); + + /** + * Fluids + */ + + // Poop Juice + public static Fluid PoopJuice; + // Manure Slurry + public static Fluid ManureSlurry; + // Fertile Manure Slurry + public static Fluid FertileManureSlurry; + // Blood + public static Fluid CustomBlood; + + /** + * Items + */ + + // Manure Byproducts + public static Item dustManureByproducts; + // Organic Fertilizer + public static Item dustOrganicFertilizer; + // Dirt + public static Item dustDirt; + + // Poop Juice + // vv - Centrifuge + // Manure Slurry && Manure Byproducts -> (Elements) Centrifuge to several tiny + // piles + // vv - Chem Reactor - Add Peat, Meat + // Organic Fertilizer + // vv - Dehydrate + // Fertilizer + + // Poop Juice + // vv - Mixer - Add Blood, Bone, Meat (1000L Poo, 200L Blood, x2 Bone, x3 Meat) + // Fertile Manure Slurry + // vv - Chem Reactor - Add Peat x1.5 + // Organic Fertilizer x3 + // vv - Dehydrate + // Fertilizer + + + @Override + public void items() { + // Nitrogen, Ammonium Nitrate, Phosphates, Calcium, Copper, Carbon + dustManureByproducts = ItemUtils.generateSpecialUseDusts("ManureByproducts", "Manure Byproduct", + "(N2H4O3)N2P2Ca3CuC8", Utils.rgbtoHexValue(110, 75, 25))[0]; + + // Basically Guano + dustOrganicFertilizer = ItemUtils.generateSpecialUseDusts("OrganicFertilizer", "Organic Fertilizer", + "Ca5(PO4)3(OH)", Utils.rgbtoHexValue(240, 240, 240))[0]; + + // Dirt Dust :) + dustDirt = ItemUtils.generateSpecialUseDusts("Dirt", "Dried Earth", Utils.rgbtoHexValue(65, 50, 15))[0]; + } + + @Override + public void blocks() { + // None yet + } + + @Override + public void fluids() { + // Sewage + PoopJuice = FluidUtils.generateFluidNonMolten("raw.waste", "Raw Animal Waste", 32 + 175, + new short[] { 100, 70, 30, 100 }, null, null, 0, true); + + // Sewage + ManureSlurry = FluidUtils.generateFluidNonMolten("manure.slurry", "Manure Slurry", 39 + 175, + new short[] { 75, 45, 15, 100 }, null, null, 0, true); + + // Sewage + FertileManureSlurry = FluidUtils.generateFluidNonMolten("fertile.manure.slurry", "Fertile Manure Slurry", + 45 + 175, new short[] { 65, 50, 15, 100 }, null, null, 0, true); + } + + + + public AgriculturalChem() { + super(); + + aBOP = LoadedMods.BiomesOPlenty; + aTiCon = LoadedMods.TiCon; + + Logger.INFO("Adding Agrochemical content"); + + FluidStack aBlood; + if (aBOP) { + aBlood = FluidUtils.getFluidStack("hell_blood", 100); + if (aBlood != null) { + Logger.INFO("Found Biome's o Plenty, enabled Blood support."); + CustomBlood = aBlood.getFluid(); + mBloodFluids.put(aBlood); + } + } + + if (aTiCon) { + aBlood = FluidUtils.getFluidStack("hell_blood", 100); + if (aBlood != null) { + Logger.INFO("Found Tinker's Construct, enabled Blood support."); + CustomBlood = aBlood.getFluid(); + mBloodFluids.put(FluidUtils.getFluidStack("blood", 100)); + } + } + + // Handle Blood Internally, Create if required. + if (mBloodFluids.isEmpty() || CustomBlood == null) { + Logger.INFO( + "Did not find any existing Blood fluids. Trying to wildcard search the fluid registry, then generate our own if that fails."); + FluidStack aTempBlood = FluidUtils.getWildcardFluidStack("blood", 100); + if (aTempBlood != null) { + CustomBlood = aTempBlood.getFluid(); + } else { + aTempBlood = FluidUtils.getWildcardFluidStack("hell_blood", 100); + if (aTempBlood == null) { + CustomBlood = FluidUtils.generateFluidNoPrefix("blood", "Blood", 32 + 175, + new short[] { 175, 25, 25, 100 }, true); + } else { + CustomBlood = aTempBlood.getFluid(); + } + } + Logger.INFO("Using " + CustomBlood.getName()); + mBloodFluids.put(FluidUtils.getFluidStack(CustomBlood, 100)); + } + + } + + private static AutoMap<ItemStack> mMeats = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mFish = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mFruits = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mVege = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mNuts = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mSeeds = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mPeat = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mBones = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mBoneMeal = new AutoMap<ItemStack>(); + + private static AutoMap<ItemStack> mList_Master_Meats = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mList_Master_FruitVege = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mList_Master_Bones = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mList_Master_Seeds = new AutoMap<ItemStack>(); + + private static void processAllOreDict() { + processOreDict("listAllmeatraw", mMeats); + processOreDict("listAllfishraw", mFish); + processOreDict("listAllfruit", mFruits); + processOreDict("listAllVeggie", mVege); + processOreDict("listAllnut", mNuts); + processOreDict("listAllSeed", mSeeds); + processOreDict("brickPeat", mPeat); + processOreDict("bone", mBones); + processOreDict("dustBone", mBoneMeal); + // Just make a mega list, makes life easier. + if (!mMeats.isEmpty()) { + for (ItemStack g : mMeats) { + mList_Master_Meats.put(g); + } + } + if (!mFish.isEmpty()) { + for (ItemStack g : mFish) { + mList_Master_Meats.put(g); + } + } + if (!mFruits.isEmpty()) { + for (ItemStack g : mFruits) { + mList_Master_FruitVege.put(g); + } + } + if (!mVege.isEmpty()) { + for (ItemStack g : mVege) { + mList_Master_FruitVege.put(g); + } + } + if (!mNuts.isEmpty()) { + for (ItemStack g : mNuts) { + mList_Master_FruitVege.put(g); + } + } + if (!mSeeds.isEmpty()) { + for (ItemStack g : mSeeds) { + mList_Master_Seeds.put(g); + } + } + if (!mBoneMeal.isEmpty()) { + for (ItemStack g : mBoneMeal) { + mList_Master_Bones.put(g); + } + } + if (!mBones.isEmpty()) { + for (ItemStack g : mBones) { + mList_Master_Bones.put(g); + } + } + } + + private static void processOreDict(String aOreName, AutoMap<ItemStack> aMap) { + ArrayList<ItemStack> aTemp = OreDictionary.getOres(aOreName); + if (!aTemp.isEmpty()) { + for (ItemStack stack : aTemp) { + aMap.put(stack); + } + } + } + + private static void addBasicSlurryRecipes() { + + ItemStack aManureByprod1 = ItemUtils.getItemStackOfAmountFromOreDict("dustTinyManureByproducts", 1); + ItemStack aManureByprod2 = ItemUtils.getItemStackOfAmountFromOreDict("dustSmallManureByproducts", 1); + ItemStack aDirtDust = ItemUtils.getSimpleStack(dustDirt, 1); + + // Poop Juice to Basic Slurry + GT_Values.RA.addCentrifugeRecipe(CI.getNumberedCircuit(10), null, FluidUtils.getFluidStack(PoopJuice, 1000), // In + // Fluid + FluidUtils.getFluidStack(ManureSlurry, 250), // Out Fluid + aDirtDust, aDirtDust, aManureByprod1, aManureByprod1, aManureByprod1, aManureByprod1, + new int[] { 2000, 2000, 500, 500, 250, 250 }, // Chances + 10 * 20, // Time + 30); // EU + + // More Efficient way to get byproducts, less Slurry + GT_Values.RA.addCentrifugeRecipe(CI.getNumberedCircuit(20), null, FluidUtils.getFluidStack(PoopJuice, 1000), // In + // Fluid + FluidUtils.getFluidStack(ManureSlurry, 50), // Out Fluid + aDirtDust, aDirtDust, aManureByprod1, aManureByprod1, aManureByprod2, aManureByprod2, + new int[] { 4000, 3000, 1250, 1250, 675, 675 }, // Chances + 20 * 20, // Time + 60); // EU + + } + + private static void addAdvancedSlurryRecipes() { + + ItemStack aCircuit = CI.getNumberedCircuit(10); + ItemStack aBone; + ItemStack aMeat; + ItemStack aEmptyCells = CI.emptyCells(2); + ItemStack aInputCells = ItemUtils.getItemStackOfAmountFromOreDict("cellRawWaste", 2); + FluidStack aOutput = FluidUtils.getFluidStack(FertileManureSlurry, 1000); + + for (FluidStack aBloodStack : mBloodFluids) { + for (ItemStack aBoneStack : mList_Master_Bones) { + aBone = ItemUtils.getSimpleStack(aBoneStack, 2); + for (ItemStack aMeatStack : mList_Master_Meats) { + aMeat = ItemUtils.getSimpleStack(aMeatStack, 5); + // Poop Juice to Fertile Slurry + GT_Values.RA.addMixerRecipe(aCircuit, aBone, aMeat, aInputCells, aBloodStack, // Input Fluid + aOutput, // Output Fluid + aEmptyCells, // Output Item + 20 * 8, // Time? + 60 // Eu? + ); + } + } + } + } + + private static void addBasicOrganiseFertRecipes() { + FluidStack aInputFluid = FluidUtils.getFluidStack(ManureSlurry, 1000); + ItemStack aOutputDust = ItemUtils.getSimpleStack(dustOrganicFertilizer, 3); + ItemStack aPeat; + ItemStack aMeat; + for (ItemStack aPeatStack : mPeat) { + aPeat = ItemUtils.getSimpleStack(aPeatStack, 3); + for (ItemStack aMeatStack : mList_Master_Meats) { + aMeat = ItemUtils.getSimpleStack(aMeatStack, 5); + CORE.RA.addChemicalRecipe(aPeat, aMeat, aInputFluid, null, aOutputDust, 20 * 20, 120); + } + + aPeat = ItemUtils.getSimpleStack(aPeatStack, 2); + for (ItemStack aMeatStack : mList_Master_FruitVege) { + aMeat = ItemUtils.getSimpleStack(aMeatStack, 9); + CORE.RA.addChemicalRecipe(aPeat, aMeat, aInputFluid, null, aOutputDust, 10 * 20, 120); + } + } + } + + private static void addAdvancedOrganiseFertRecipes() { + FluidStack aInputFluid = FluidUtils.getFluidStack(FertileManureSlurry, 1000); + ItemStack aOutputDust = ItemUtils.getSimpleStack(dustOrganicFertilizer, 7); + ItemStack aPeat; + ItemStack aMeat; + for (ItemStack aPeatStack : mPeat) { + aPeat = ItemUtils.getSimpleStack(aPeatStack, 5); + for (ItemStack aMeatStack : mList_Master_Meats) { + aMeat = ItemUtils.getSimpleStack(aMeatStack, 7); + CORE.RA.addChemicalRecipe(aPeat, aMeat, aInputFluid, null, aOutputDust, 10 * 20, 140); + } + aPeat = ItemUtils.getSimpleStack(aPeatStack, 3); + for (ItemStack aMeatStack : mList_Master_FruitVege) { + aMeat = ItemUtils.getSimpleStack(aMeatStack, 12); + CORE.RA.addChemicalRecipe(aPeat, aMeat, aInputFluid, null, aOutputDust, 5 * 20, 140); + } + } + } + + private static void addMiscRecipes() { + + ItemStack aDustOrganicFert = ItemUtils.getSimpleStack(dustOrganicFertilizer, 1); + ItemStack aManureByprod = ItemUtils.getSimpleStack(dustManureByproducts, 1); + + // Dehydrate Organise Fert to Normal Fert. + + /** + * Forestry Support + */ + if (LoadedMods.Forestry) { + + Item aForestryFert = PluginCore.items.fertilizerCompound; + + CORE.RA.addDehydratorRecipe( + new ItemStack[] { CI.getNumberedCircuit(11), ItemUtils.getSimpleStack(aDustOrganicFert, 4) }, null, + null, new ItemStack[] { ItemUtils.getSimpleStack(aForestryFert, 3), aManureByprod, aManureByprod }, + new int[] { 10000, 2000, 2000 }, 20 * 20, 240); + } + + /** + * IC2 Support + */ + if (LoadedMods.IndustrialCraft2) { + CORE.RA.addDehydratorRecipe( + new ItemStack[] { CI.getNumberedCircuit(12), ItemUtils.getSimpleStack(aDustOrganicFert, 4) }, null, + null, new ItemStack[] { ItemUtils.getItemStackFromFQRN("IC2:itemFertilizer", 3), aManureByprod, + aManureByprod }, + new int[] { 10000, 2000, 2000 }, 20 * 20, 240); + } + + // Dirt Production + CORE.RA.addCompressorRecipe(ItemUtils.getSimpleStack(dustDirt, 9), ItemUtils.getSimpleStack(Blocks.dirt), + 20 * 2, 8); + + // Centrifuge Byproducts + + // Ammonium Nitrate, Phosphates, Calcium, Copper, Carbon + GT_Values.RA.addCentrifugeRecipe(CI.getNumberedCircuit(20), ItemUtils.getSimpleStack(aManureByprod, 4), + FluidUtils.getFluidStack("sulfuricacid", 250), // In Fluid + FluidUtils.getFluidStack("sulfuricapatite", 50), // Out Fluid + Materials.Phosphorus.getDustSmall(2), Materials.Calcium.getDustSmall(2), + Materials.Copper.getDustTiny(1), Materials.Carbon.getDust(1), ItemUtils.getSimpleStack(dustDirt, 1), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyAmmoniumNitrate", 1), + new int[] { 2500, 2500, 750, 1000, 5000, 250 }, // Chances + 20 * 20, // Time + 60); // EU + + // Add Fuel Usages + CORE.RA.addSemifluidFuel(FluidUtils.getFluidStack(PoopJuice, 1000), 12); + CORE.RA.addSemifluidFuel(FluidUtils.getFluidStack(ManureSlurry, 1000), 24); + CORE.RA.addSemifluidFuel(FluidUtils.getFluidStack(FertileManureSlurry, 1000), 32); + + } + + @Override + public String errorMessage() { + // TODO Auto-generated method stub + return "Failed to generate recipes for AgroChem."; + } + + @Override + public boolean generateRecipes() { + if (mBloodFluids.isEmpty()) { + Logger.INFO("Could not find, nor create Blood fluid. Unable to add recipes."); + return false; + } + + // Organise OreDict + processAllOreDict(); + + // Slurry Production + addBasicSlurryRecipes(); + addAdvancedSlurryRecipes(); + + // Organic Fert. Production + addBasicOrganiseFertRecipes(); + addAdvancedOrganiseFertRecipes(); + + addMiscRecipes(); + return true; + } +} diff --git a/src/Java/gtPlusPlus/core/item/chemistry/CoalTar.java b/src/Java/gtPlusPlus/core/item/chemistry/CoalTar.java index eea1aed49f..e060723afd 100644 --- a/src/Java/gtPlusPlus/core/item/chemistry/CoalTar.java +++ b/src/Java/gtPlusPlus/core/item/chemistry/CoalTar.java @@ -8,7 +8,7 @@ import gregtech.api.enums.Materials; import gregtech.api.enums.OrePrefixes; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; - +import gtPlusPlus.api.objects.minecraft.ItemPackage; import gtPlusPlus.core.item.ModItems; import gtPlusPlus.core.item.base.BaseItemComponent; import gtPlusPlus.core.lib.CORE; @@ -21,9 +21,10 @@ import gtPlusPlus.core.util.reflect.AddGregtechRecipe; import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.FluidStack; -public class CoalTar { +public class CoalTar extends ItemPackage { public static Fluid Coal_Gas; + public static Fluid Coal_Oil; public static Fluid Ethylene; public static Fluid Benzene; public static Fluid Ethylbenzene; @@ -39,116 +40,6 @@ public class CoalTar { public static Fluid Hydrogen_Peroxide; public static Fluid Lithium_Peroxide; - public static void run(){ - - //Special Compatibility for Coke - ItemUtils.addItemToOreDictionary(ItemUtils.getSimpleStack(ModItems.itemCoalCoke, 1), "fuelCoke"); - //Create Coal Gas - Coal_Gas = FluidUtils.generateFluidNonMolten("CoalGas", "Coal Gas", 500, new short[]{48, 48, 48, 100}, null, null); - //Ethanol - // v - Dehydrate cells to remove water - - - //Create Ethylene - if (!FluidUtils.doesFluidExist("Ethylene")){ - Ethylene = FluidUtils.generateFluidNonMolten("Ethylene", "Ethylene", -103, new short[]{255, 255, 255, 100}, null, null); - } - else { - Ethylene = FluidUtils.getWildcardFluidStack("Ethylene", 1).getFluid(); - } - - //Create Benzene - (Toluene + Hydrogen | 95% Benzene / 5% methane) - if (!FluidUtils.doesFluidExist("NitrousOxide")){ - Benzene = FluidUtils.generateFluidNonMolten("Benzene", "Benzene", 81, new short[]{150, 75, 0, 100}, null, null); - } - else { - Benzene = FluidUtils.getWildcardFluidStack("Benzene", 1).getFluid(); - } - - //Create Ethylbenzene - Ethylbenzene is produced in on a large scale by combining benzene and ethylene in an acid-catalyzed chemical reaction - //Use Chemical Reactor - Ethylbenzene = FluidUtils.generateFluidNonMolten("Ethylbenzene", "Ethylbenzene", 136, new short[]{255, 255, 255, 100}, null, null); - //Create Anthracene - Anthracene = FluidUtils.generateFluidNonMolten("Anthracene", "Anthracene", 340, new short[]{255, 255, 255, 100}, null, null); - //Toluene - if (!FluidUtils.doesFluidExist("Toluene")){ - Toluene = FluidUtils.generateFluidNonMolten("Toluene", "Toluene", -95, new short[]{140, 70, 20, 100}, null, null); - } - else { - Toluene = FluidUtils.getWildcardFluidStack("Toluene", 1).getFluid(); - Item itemCellToluene = new BaseItemComponent("Toluene", "Toluene", new short[]{140, 70, 20, 100}); - MaterialGenerator.addFluidCannerRecipe(ItemUtils.getEmptyCell(), ItemUtils.getSimpleStack(itemCellToluene), FluidUtils.getFluidStack(Toluene, 1000), null); - } - - //Create Coal Tar - Coal_Tar = FluidUtils.generateFluidNonMolten("CoalTar", "Coal Tar", 450, new short[]{32, 32, 32, 100}, null, null); - // v - Distill (60% Tar oil/15% Naphtha/20% Ethylbenzene/5% Anthracene) - //Create Coal Tar Oil - Coal_Tar_Oil = FluidUtils.generateFluidNonMolten("CoalTarOil", "Coal Tar Oil", 240, new short[]{240, 240, 150, 100}, null, null); - // v - Wash With Sulfuric Acid - //Create Sulfuric Coal Tar Oil - Sulfuric_Coal_Tar_Oil = FluidUtils.generateFluidNonMolten("SulfuricCoalTarOil", "Sulfuric Coal Tar Oil", 240, new short[]{250, 170, 12, 100}, null, null); - // v - Distill (No loss, just time consuming) - //Create Naphthalene - Naphthalene = FluidUtils.generateFluidNonMolten("Naphthalene", "Naphthalene", 115, new short[]{210, 185, 135, 100}, null, null); - // v - Oxidize with mercury and nitric acid - //Create Phthalic Acid - Phthalic_Acid = FluidUtils.generateFluidNonMolten("PhthalicAcid", "Phthalic Acid", 207, new short[]{210, 220, 210, 100}, null, null); - // v - Dehydrate at 180C+ - //Create Phthalic Anhydride - ItemUtils.generateSpecialUseDusts("PhthalicAnhydride", "Phthalic Anhydride", "C6H4(CO)2O", Utils.rgbtoHexValue(175, 175, 175)); - - - - //Create 2-Ethylanthraquinone - //2-Ethylanthraquinone is prepared from the reaction of phthalic anhydride and ethylbenzene - Ethylanthraquinone2 = FluidUtils.generateFluidNonMolten("2Ethylanthraquinone", "2-Ethylanthraquinone", 415, new short[]{227, 255, 159, 100}, null, null); - //Create 2-Ethylanthrahydroquinone - //Palladium plate + Hydrogen(250) + 2-Ethylanthraquinone(500) = 600 Ethylanthrahydroquinone - Ethylanthrahydroquinone2 = FluidUtils.generateFluidNonMolten("2Ethylanthrahydroquinone", "2-Ethylanthrahydroquinone", 415, new short[]{207, 225, 129, 100}, null, null); - //Create Hydrogen Peroxide - //Compressed Air(1500) + Ethylanthrahydroquinone(500) + Anthracene(5) = 450 Ethylanthraquinone && 200 Peroxide - Hydrogen_Peroxide = FluidUtils.generateFluidNonMolten("HydrogenPeroxide", "Hydrogen Peroxide", 150, new short[]{210, 255, 255, 100}, null, null); - - - - //Lithium Hydroperoxide - LiOH + H2O2 → LiOOH + 2 H2O - ItemUtils.generateSpecialUseDusts("LithiumHydroperoxide", "Lithium Hydroperoxide", "HLiO2", Utils.rgbtoHexValue(125, 125, 125)); - // v - Dehydrate - //Lithium Peroxide - 2 LiOOH → Li2O2 + H2O2 + 2 H2O - Lithium_Peroxide = FluidUtils.generateFluidNonMolten("LithiumPeroxide", "Lithium Peroxide", 446, new short[]{135, 135, 135, 100}, null, null); - - //Burn the coal gas! - GT_Values.RA.addFuel(ItemUtils.getItemStackOfAmountFromOreDict("cellCoalGas", 1), null, 96, 1); - GT_Values.RA.addFuel(ItemUtils.getItemStackOfAmountFromOreDict("cellSulfuricCoalTarOil", 1), null, 32, 3); - GT_Values.RA.addFuel(ItemUtils.getItemStackOfAmountFromOreDict("cellCoalTarOil", 1), null, 64, 3); - GT_Values.RA.addFuel(ItemUtils.getItemStackOfAmountFromOreDict("cellCoalTar", 1), null, 128, 3); - createRecipes(); - - - } - - private static void createRecipes() { - recipeCreateEthylene(); - recipeCreateBenzene(); - recipeCreateEthylbenzene(); - - recipeCoalToCoalTar(); - recipeCoalTarToCoalTarOil(); - recipeCoalTarOilToSulfuricOilToNaphthalene(); - recipeNaphthaleneToPhthalicAcid(); - recipePhthalicAcidToPhthalicAnhydride(); - recipe2Ethylanthraquinone(); - recipe2Ethylanthrahydroquinone(); - recipeHydrogenPeroxide(); - recipeLithiumHydroperoxide(); - recipeLithiumPeroxide(); - - recipeEthylBenzineFuelsIntoHeavyFuel(); - } - - - private static void recipeEthylBenzineFuelsIntoHeavyFuel() { CORE.RA.addChemicalRecipe( ItemUtils.getItemStackOfAmountFromOreDict("cellFuel", 9), @@ -228,6 +119,15 @@ public class CoalTar { public static void recipeCoalToCoalTar(){ + //Charcoal + AddGregtechRecipe.addCokeAndPyrolyseRecipes( + GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Charcoal, 32L), + 8, + GT_Values.NF, + ItemUtils.getItemStackOfAmountFromOreDict("dustSmallDirt", 2), + FluidUtils.getFluidStack("fluid.coaltar", 800), + 15, + 120); //Lignite AddGregtechRecipe.addCokeAndPyrolyseRecipes( GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Lignite, 16L), @@ -235,7 +135,7 @@ public class CoalTar { GT_Values.NF, ItemUtils.getItemStackOfAmountFromOreDict("dustSmallDarkAsh", 2), FluidUtils.getFluidStack("fluid.coaltar", 800), - 90, + 45, 60); //Coal @@ -245,7 +145,7 @@ public class CoalTar { GT_Values.NF, ItemUtils.getItemStackOfAmountFromOreDict("dustSmallDarkAsh", 2), FluidUtils.getFluidStack("fluid.coaltar", 2200), - 60, + 30, 120); //Coke @@ -255,7 +155,7 @@ public class CoalTar { GT_Values.NF, ItemUtils.getItemStackOfAmountFromOreDict("dustSmallAsh", 3), FluidUtils.getFluidStack("fluid.coaltar", 3400), - 30, + 15, 240); } @@ -295,14 +195,24 @@ public class CoalTar { 900, //aDuration 30,//aEUt false //Hidden? - ); + ); + GT_Values.RA.addDistilleryRecipe( + CI.getNumberedCircuit(5), //Circuit + FluidUtils.getFluidStack("fluid.coaltar", 1500), //aInput + FluidUtils.getFluidStack("fluid.kerosene", 400), //aOutput + 300, //aDuration + 64,//aEUt + false //Hidden? + ); + GT_Values.RA.addDistillationTowerRecipe( FluidUtils.getFluidStack("fluid.coaltar", 1000), new FluidStack[]{ - FluidUtils.getFluidStack("fluid.coaltaroil", 600), //aOutput - FluidUtils.getFluidStack("liquid_naphtha", 150), //aOutput - FluidUtils.getFluidStack("fluid.ethylbenzene", 200), //aOutput + FluidUtils.getFluidStack("fluid.coaltaroil", 500), //aOutput + FluidUtils.getFluidStack("liquid_naphtha", 100), //aOutput + FluidUtils.getFluidStack("fluid.ethylbenzene", 150), //aOutput FluidUtils.getFluidStack("fluid.anthracene", 50), //aOutput + FluidUtils.getFluidStack("fluid.kerosene", 200), //aOutput }, null, 900, @@ -430,4 +340,141 @@ public class CoalTar { 240); } + @Override + public String errorMessage() { + // TODO Auto-generated method stub + return "Bad Coal Science!"; + } + + @Override + public boolean generateRecipes() { + recipeCreateEthylene(); + recipeCreateBenzene(); + recipeCreateEthylbenzene(); + + recipeCoalToCoalTar(); + recipeCoalTarToCoalTarOil(); + recipeCoalTarOilToSulfuricOilToNaphthalene(); + recipeNaphthaleneToPhthalicAcid(); + recipePhthalicAcidToPhthalicAnhydride(); + recipe2Ethylanthraquinone(); + recipe2Ethylanthrahydroquinone(); + recipeHydrogenPeroxide(); + recipeLithiumHydroperoxide(); + recipeLithiumPeroxide(); + + recipeEthylBenzineFuelsIntoHeavyFuel(); + + //Burn the coal gas! + GT_Values.RA.addFuel(ItemUtils.getItemStackOfAmountFromOreDict("cellCoalGas", 1), null, 96, 1); + CORE.RA.addSemifluidFuel(ItemUtils.getItemStackOfAmountFromOreDict("cellSulfuricCoalTarOil", 1), 64); + CORE.RA.addSemifluidFuel(ItemUtils.getItemStackOfAmountFromOreDict("cellCoalTarOil", 1), 32); + CORE.RA.addSemifluidFuel(ItemUtils.getItemStackOfAmountFromOreDict("cellCoalTar", 1), 16); + + return true; + } + + @Override + public void items() { + //Phthalic_Acid = FluidUtils.generateFluidNonMolten("PhthalicAcid", "Phthalic Acid", 207, new short[]{210, 220, 210, 100}, null, null); + // v - Dehydrate at 180C+ + //Create Phthalic Anhydride + ItemUtils.generateSpecialUseDusts("PhthalicAnhydride", "Phthalic Anhydride", "C6H4(CO)2O", Utils.rgbtoHexValue(175, 175, 175)); + + //Lithium Hydroperoxide - LiOH + H2O2 → LiOOH + 2 H2O + ItemUtils.generateSpecialUseDusts("LithiumHydroperoxide", "Lithium Hydroperoxide", "HLiO2", Utils.rgbtoHexValue(125, 125, 125)); + // v - Dehydrate + //Lithium Peroxide - 2 LiOOH → Li2O2 + H2O2 + 2 H2O + //Lithium_Peroxide = FluidUtils.generateFluidNonMolten("LithiumPeroxide", "Lithium Peroxide", 446, new short[]{135, 135, 135, 100}, null, null); + } + + @Override + public void blocks() { + // TODO Auto-generated method stub + + } + + @Override + public void fluids() { + + + //Special Compatibility for Coke + ItemUtils.addItemToOreDictionary(ItemUtils.getSimpleStack(ModItems.itemCoalCoke, 1), "fuelCoke"); + //Create Coal Gas + Coal_Gas = FluidUtils.generateFluidNonMolten("CoalGas", "Coal Gas", 500, new short[]{48, 48, 48, 100}, null, null); + //Ethanol + // v - Dehydrate cells to remove water + + + //Create Ethylene + if (!FluidUtils.doesFluidExist("Ethylene")){ + Ethylene = FluidUtils.generateFluidNonMolten("Ethylene", "Ethylene", -103, new short[]{255, 255, 255, 100}, null, null); + } + else { + Ethylene = FluidUtils.getWildcardFluidStack("Ethylene", 1).getFluid(); + } + + //Create Benzene - (Toluene + Hydrogen | 95% Benzene / 5% methane) + if (!FluidUtils.doesFluidExist("NitrousOxide")){ + Benzene = FluidUtils.generateFluidNonMolten("Benzene", "Benzene", 81, new short[]{150, 75, 0, 100}, null, null); + } + else { + Benzene = FluidUtils.getWildcardFluidStack("Benzene", 1).getFluid(); + } + + //Create Ethylbenzene - Ethylbenzene is produced in on a large scale by combining benzene and ethylene in an acid-catalyzed chemical reaction + //Use Chemical Reactor + Ethylbenzene = FluidUtils.generateFluidNonMolten("Ethylbenzene", "Ethylbenzene", 136, new short[]{255, 255, 255, 100}, null, null); + //Create Anthracene + Anthracene = FluidUtils.generateFluidNonMolten("Anthracene", "Anthracene", 340, new short[]{255, 255, 255, 100}, null, null); + //Toluene + if (!FluidUtils.doesFluidExist("Toluene")){ + Toluene = FluidUtils.generateFluidNonMolten("Toluene", "Toluene", -95, new short[]{140, 70, 20, 100}, null, null); + } + else { + Toluene = FluidUtils.getWildcardFluidStack("Toluene", 1).getFluid(); + Item itemCellToluene = new BaseItemComponent("Toluene", "Toluene", new short[]{140, 70, 20, 100}); + MaterialGenerator.addFluidCannerRecipe(ItemUtils.getEmptyCell(), ItemUtils.getSimpleStack(itemCellToluene), FluidUtils.getFluidStack(Toluene, 1000), null); + } + + //Create Coal Tar + Coal_Tar = FluidUtils.generateFluidNonMolten("CoalTar", "Coal Tar", 450, new short[]{32, 32, 32, 100}, null, null); + // v - Distill (60% Tar oil/15% Naphtha/20% Ethylbenzene/5% Anthracene) + //Create Coal Tar Oil + Coal_Tar_Oil = FluidUtils.generateFluidNonMolten("CoalTarOil", "Coal Tar Oil", 240, new short[]{240, 240, 150, 100}, null, null); + // v - Wash With Sulfuric Acid + //Create Sulfuric Coal Tar Oil + Sulfuric_Coal_Tar_Oil = FluidUtils.generateFluidNonMolten("SulfuricCoalTarOil", "Sulfuric Coal Tar Oil", 240, new short[]{250, 170, 12, 100}, null, null); + // v - Distill (No loss, just time consuming) + //Create Naphthalene + Naphthalene = FluidUtils.generateFluidNonMolten("Naphthalene", "Naphthalene", 115, new short[]{210, 185, 135, 100}, null, null); + // v - Oxidize with mercury and nitric acid + //Create Phthalic Acid + Phthalic_Acid = FluidUtils.generateFluidNonMolten("PhthalicAcid", "Phthalic Acid", 207, new short[]{210, 220, 210, 100}, null, null); + // v - Dehydrate at 180C+ + //Create Phthalic Anhydride + //ItemUtils.generateSpecialUseDusts("PhthalicAnhydride", "Phthalic Anhydride", "C6H4(CO)2O", Utils.rgbtoHexValue(175, 175, 175)); + + + + //Create 2-Ethylanthraquinone + //2-Ethylanthraquinone is prepared from the reaction of phthalic anhydride and ethylbenzene + Ethylanthraquinone2 = FluidUtils.generateFluidNonMolten("2Ethylanthraquinone", "2-Ethylanthraquinone", 415, new short[]{227, 255, 159, 100}, null, null); + //Create 2-Ethylanthrahydroquinone + //Palladium plate + Hydrogen(250) + 2-Ethylanthraquinone(500) = 600 Ethylanthrahydroquinone + Ethylanthrahydroquinone2 = FluidUtils.generateFluidNonMolten("2Ethylanthrahydroquinone", "2-Ethylanthrahydroquinone", 415, new short[]{207, 225, 129, 100}, null, null); + //Create Hydrogen Peroxide + //Compressed Air(1500) + Ethylanthrahydroquinone(500) + Anthracene(5) = 450 Ethylanthraquinone && 200 Peroxide + Hydrogen_Peroxide = FluidUtils.generateFluidNonMolten("HydrogenPeroxide", "Hydrogen Peroxide", 150, new short[]{210, 255, 255, 100}, null, null); + + + + //Lithium Hydroperoxide - LiOH + H2O2 → LiOOH + 2 H2O + //ItemUtils.generateSpecialUseDusts("LithiumHydroperoxide", "Lithium Hydroperoxide", "HLiO2", Utils.rgbtoHexValue(125, 125, 125)); + // v - Dehydrate + //Lithium Peroxide - 2 LiOOH → Li2O2 + H2O2 + 2 H2O + Lithium_Peroxide = FluidUtils.generateFluidNonMolten("LithiumPeroxide", "Lithium Peroxide", 446, new short[]{135, 135, 135, 100}, null, null); + + } + } diff --git a/src/Java/gtPlusPlus/core/item/chemistry/GenericChem.java b/src/Java/gtPlusPlus/core/item/chemistry/GenericChem.java new file mode 100644 index 0000000000..1c66b5cac2 --- /dev/null +++ b/src/Java/gtPlusPlus/core/item/chemistry/GenericChem.java @@ -0,0 +1,106 @@ +package gtPlusPlus.core.item.chemistry; + +import gregtech.api.enums.TextureSet; +import gtPlusPlus.api.objects.minecraft.ItemPackage; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.material.state.MaterialState; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import net.minecraft.item.Item; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; + +public class GenericChem extends ItemPackage { + + /** + * Materials + */ + + public static final Material BAKELITE = new Material("Bakelite", MaterialState.SOLID, TextureSet.SET_DULL, new short[]{90, 140, 140}, 120, 240, 23, 24, true, "", 0);//Not a GT Inherited Material + public static final Material NYLON = new Material("Nylon", MaterialState.SOLID, TextureSet.SET_SHINY, new short[]{45, 45, 45}, 300, 600, 44, 48, true, "", 0);//Not a GT Inherited Material + + //public static final Material HYPOGEN = new Material("Hypogen", MaterialState.SOLID, TextureSets.NUCLEAR.get(), new short[]{220, 120, 75}, 12255, 19377, 240, 251, true, "Hy⚶", 0);//Not a GT Inherited Material + //public static final Material HYPOGEN = new Material("Hypogen", MaterialState.SOLID, TextureSets.NUCLEAR.get(), new short[]{220, 120, 75}, 12255, 19377, 240, 251, true, "Hy⚶", 0);//Not a GT Inherited Material + //public static final Material Nylon = new Material(); + + /** + * Fluids + */ + + public Fluid Benzene; + public Fluid NitroBenzene; + public Fluid Aniline; + public Fluid Polyurethane; + public Fluid Phenol; //https://en.wikipedia.org/wiki/Phenol#Uses + public Fluid Cyclohexane; //https://en.wikipedia.org/wiki/Cyclohexane + public Fluid Cyclohexanone; //https://en.wikipedia.org/wiki/Cyclohexanone + + public Fluid Cadaverine; //https://en.wikipedia.org/wiki/Cadaverine + public Fluid Putrescine; //https://en.wikipedia.org/wiki/Putrescine + + + /** + * Items + */ + + // Phenol Byproducts + public Item PhenolicResins; //https://en.wikipedia.org/wiki/Phenol_formaldehyde_resin + + + + @Override + public void items() { + PhenolicResins = ItemUtils.generateSpecialUseDusts("phenolicresins", "Phenolic Resin", "HOC6H4CH2OH", Utils.rgbtoHexValue(80, 40, 40))[0]; + MaterialGenerator.generate(BAKELITE, false); + MaterialGenerator.generate(NYLON, false); + } + + @Override + public void blocks() {} + + @Override + public void fluids() { + + if (!FluidRegistry.isFluidRegistered("benzene")) { + Benzene = FluidUtils.generateFluidNoPrefix("benzene", "Benzene", 278, new short[] { 100, 70, 30, 100 }, true); + } + else { + Benzene = FluidRegistry.getFluid("benzene"); + } + + NitroBenzene = FluidUtils.generateFluidNoPrefix("nitrobenzene", "NitroBenzene", 278, new short[] { 70, 50, 40, 100 }, true); + + Aniline = FluidUtils.generateFluidNoPrefix("aniline", "Aniline", 266, new short[] { 100, 100, 30, 100 }, true); + + Polyurethane = FluidUtils.generateFluidNoPrefix("polyurethane", "Polyurethane", 350, new short[] { 100, 70, 100, 100 }, true); + + if (!FluidRegistry.isFluidRegistered("phenol")) { + Phenol = FluidUtils.generateFluidNoPrefix("phenol", "Phenol", 313, new short[] { 100, 70, 30, 100 }, true); + } + else { + Phenol = FluidRegistry.getFluid("phenol"); + } + + Cyclohexane = FluidUtils.generateFluidNoPrefix("cyclohexane", "Cyclohexane", 32 + 175, new short[] { 100, 70, 30, 100 }, true); + Cyclohexanone = FluidUtils.generateFluidNoPrefix("cyclohexanone", "Cyclohexanone", 32 + 175, new short[] { 100, 70, 30, 100 }, true); + + Cadaverine = FluidUtils.generateFluidNoPrefix("cadaverine", "Cadaverine", 32 + 175, new short[] { 100, 70, 30, 100 }, true); + Putrescine = FluidUtils.generateFluidNoPrefix("putrescine", "Putrescine", 32 + 175, new short[] { 100, 70, 30, 100 }, true); + + } + + @Override + public String errorMessage() { + // TODO Auto-generated method stub + return "Failed to generate recipes for AgroChem."; + } + + @Override + public boolean generateRecipes() { + + + return true; + } +} diff --git a/src/Java/gtPlusPlus/core/item/chemistry/NuclearChem.java b/src/Java/gtPlusPlus/core/item/chemistry/NuclearChem.java index 1d45dec183..25beb6d9b5 100644 --- a/src/Java/gtPlusPlus/core/item/chemistry/NuclearChem.java +++ b/src/Java/gtPlusPlus/core/item/chemistry/NuclearChem.java @@ -3,7 +3,7 @@ package gtPlusPlus.core.item.chemistry; import net.minecraft.init.Items; import gregtech.api.enums.GT_Values; - +import gtPlusPlus.api.objects.minecraft.ItemPackage; import gtPlusPlus.core.item.ModItems; import gtPlusPlus.core.lib.CORE; import gtPlusPlus.core.recipe.common.CI; @@ -11,18 +11,40 @@ import gtPlusPlus.core.util.minecraft.FluidUtils; import gtPlusPlus.core.util.minecraft.ItemUtils; import net.minecraftforge.fluids.Fluid; -public class NuclearChem { +public class NuclearChem extends ItemPackage { public static Fluid Burnt_LiFBeF2ThF4UF4; public static Fluid Burnt_LiFBeF2ZrF4UF4; public static Fluid Burnt_LiFBeF2ZrF4U235; public static Fluid GeneticMutagen; - private static boolean generateMutagenRecipe = false; + private static boolean generateMutagenRecipe = false; + + @Override + public String errorMessage() { + return "bad Nuclear Chemistry Recipes."; + } - public static void run(){ + @Override + public boolean generateRecipes() { + if (generateMutagenRecipe) { + chemReator_CreateMutagen(); + } + chemReactor_MutagenWithEggs(); + return true; + } + + @Override + public void items() { + } + + @Override + public void blocks() { + } - //Create Coal Gas + @Override + public void fluids() { + //Create Used Nuclear Fuels Burnt_LiFBeF2ThF4UF4 = FluidUtils.generateFluidNonMolten("BurntLiFBeF2ThF4UF4", "Burnt LiFBeF2ThF4UF4 Salt", 545, new short[]{48, 175, 48, 100}, null, null); Burnt_LiFBeF2ZrF4UF4 = FluidUtils.generateFluidNonMolten("BurntLiFBeF2ZrF4UF4", "Burnt LiFBeF2ZrF4UF4 Salt", 520, new short[]{48, 168, 68, 100}, null, null); Burnt_LiFBeF2ZrF4U235 = FluidUtils.generateFluidNonMolten("BurntLiFBeF2ZrF4U235", "Burnt LiFBeF2ZrF4U235 Salt", 533, new short[]{68, 185, 48, 100}, null, null); @@ -34,18 +56,6 @@ public class NuclearChem { else { GeneticMutagen = FluidUtils.getFluidStack("fluid.Mutagen", 1).getFluid(); } - - createRecipes(); - - - } - - private static void createRecipes() { - - if (generateMutagenRecipe) - chemReator_CreateMutagen(); - - chemReactor_MutagenWithEggs(); } private static void chemReator_CreateMutagen() { diff --git a/src/Java/gtPlusPlus/core/item/chemistry/OilChem.java b/src/Java/gtPlusPlus/core/item/chemistry/OilChem.java new file mode 100644 index 0000000000..cb7e32eaf0 --- /dev/null +++ b/src/Java/gtPlusPlus/core/item/chemistry/OilChem.java @@ -0,0 +1,201 @@ +package gtPlusPlus.core.item.chemistry; + +import java.util.ArrayList; + +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.api.objects.minecraft.ItemPackage; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.oredict.OreDictionary; + +public class OilChem extends ItemPackage { + + /** + * Fluids + */ + + // Poop Juice + public static Fluid PoopJuice; + // Manure Slurry + public static Fluid ManureSlurry; + // Fertile Manure Slurry + public static Fluid FertileManureSlurry; + + /** + * Items + */ + + // Manure Byproducts + public static Item dustManureByproducts; + // Organic Fertilizer + public static Item dustOrganicFertilizer; + // Dirt + public static Item dustDirt; + + // Poop Juice + // vv - Centrifuge + // Manure Slurry && Manure Byproducts -> (Elements) Centrifuge to several tiny + // piles + // vv - Chem Reactor - Add Peat, Meat + // Organic Fertilizer + // vv - Dehydrate + // Fertilizer + + // Poop Juice + // vv - Mixer - Add Blood, Bone, Meat (1000L Poo, 200L Blood, x2 Bone, x3 Meat) + // Fertile Manure Slurry + // vv - Chem Reactor - Add Peat x1.5 + // Organic Fertilizer x3 + // vv - Dehydrate + // Fertilizer + + + @Override + public void items() { + // Nitrogen, Ammonium Nitrate, Phosphates, Calcium, Copper, Carbon + dustManureByproducts = ItemUtils.generateSpecialUseDusts("ManureByproducts", "Manure Byproduct", + "(N2H4O3)N2P2Ca3CuC8", Utils.rgbtoHexValue(110, 75, 25))[0]; + + // Basically Guano + dustOrganicFertilizer = ItemUtils.generateSpecialUseDusts("OrganicFertilizer", "Organic Fertilizer", + "Ca5(PO4)3(OH)", Utils.rgbtoHexValue(240, 240, 240))[0]; + + // Dirt Dust :) + dustDirt = ItemUtils.generateSpecialUseDusts("Dirt", "Dried Earth", Utils.rgbtoHexValue(65, 50, 15))[0]; + } + + @Override + public void blocks() { + // None yet + } + + @Override + public void fluids() { + // Sewage + PoopJuice = FluidUtils.generateFluidNonMolten("raw.waste", "Raw Animal Waste", 32 + 175, + new short[] { 100, 70, 30, 100 }, null, null, 0, true); + + // Sewage + ManureSlurry = FluidUtils.generateFluidNonMolten("manure.slurry", "Manure Slurry", 39 + 175, + new short[] { 75, 45, 15, 100 }, null, null, 0, true); + + // Sewage + FertileManureSlurry = FluidUtils.generateFluidNonMolten("fertile.manure.slurry", "Fertile Manure Slurry", + 45 + 175, new short[] { 65, 50, 15, 100 }, null, null, 0, true); + } + + private static AutoMap<ItemStack> mMeats = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mFish = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mFruits = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mVege = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mNuts = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mSeeds = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mPeat = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mBones = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mBoneMeal = new AutoMap<ItemStack>(); + + private static AutoMap<ItemStack> mList_Master_Meats = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mList_Master_FruitVege = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mList_Master_Bones = new AutoMap<ItemStack>(); + private static AutoMap<ItemStack> mList_Master_Seeds = new AutoMap<ItemStack>(); + + private static void processAllOreDict() { + processOreDict("listAllmeatraw", mMeats); + processOreDict("listAllfishraw", mFish); + processOreDict("listAllfruit", mFruits); + processOreDict("listAllVeggie", mVege); + processOreDict("listAllnut", mNuts); + processOreDict("listAllSeed", mSeeds); + processOreDict("brickPeat", mPeat); + processOreDict("bone", mBones); + processOreDict("dustBone", mBoneMeal); + // Just make a mega list, makes life easier. + if (!mMeats.isEmpty()) { + for (ItemStack g : mMeats) { + mList_Master_Meats.put(g); + } + } + if (!mFish.isEmpty()) { + for (ItemStack g : mFish) { + mList_Master_Meats.put(g); + } + } + if (!mFruits.isEmpty()) { + for (ItemStack g : mFruits) { + mList_Master_FruitVege.put(g); + } + } + if (!mVege.isEmpty()) { + for (ItemStack g : mVege) { + mList_Master_FruitVege.put(g); + } + } + if (!mNuts.isEmpty()) { + for (ItemStack g : mNuts) { + mList_Master_FruitVege.put(g); + } + } + if (!mSeeds.isEmpty()) { + for (ItemStack g : mSeeds) { + mList_Master_Seeds.put(g); + } + } + if (!mBoneMeal.isEmpty()) { + for (ItemStack g : mBoneMeal) { + mList_Master_Bones.put(g); + } + } + if (!mBones.isEmpty()) { + for (ItemStack g : mBones) { + mList_Master_Bones.put(g); + } + } + } + + private static void processOreDict(String aOreName, AutoMap<ItemStack> aMap) { + ArrayList<ItemStack> aTemp = OreDictionary.getOres(aOreName); + if (!aTemp.isEmpty()) { + for (ItemStack stack : aTemp) { + aMap.put(stack); + } + } + } + + private static void addBasicSlurryRecipes() {} + + private static void addAdvancedSlurryRecipes() {} + + private static void addBasicOrganiseFertRecipes() {} + + private static void addAdvancedOrganiseFertRecipes() {} + + private static void addMiscRecipes() {} + + @Override + public String errorMessage() { + // TODO Auto-generated method stub + return "Failed to generate recipes for AgroChem."; + } + + @Override + public boolean generateRecipes() { + + // Organise OreDict + processAllOreDict(); + + // Slurry Production + addBasicSlurryRecipes(); + addAdvancedSlurryRecipes(); + + // Organic Fert. Production + addBasicOrganiseFertRecipes(); + addAdvancedOrganiseFertRecipes(); + + addMiscRecipes(); + return true; + } +} diff --git a/src/Java/gtPlusPlus/core/item/chemistry/RocketFuels.java b/src/Java/gtPlusPlus/core/item/chemistry/RocketFuels.java index a516cb0639..f2b5d0683c 100644 --- a/src/Java/gtPlusPlus/core/item/chemistry/RocketFuels.java +++ b/src/Java/gtPlusPlus/core/item/chemistry/RocketFuels.java @@ -1,31 +1,37 @@ package gtPlusPlus.core.item.chemistry; -import net.minecraft.item.Item; -import net.minecraft.item.ItemStack; - import java.util.HashMap; import java.util.HashSet; +import java.util.LinkedHashMap; +import cpw.mods.fml.common.event.FMLLoadCompleteEvent; import gregtech.api.enums.GT_Values; import gregtech.api.enums.Materials; +import gregtech.api.util.GT_Recipe; import gregtech.api.util.Recipe_GT; -import gtPlusPlus.api.objects.data.AutoMap; -import gtPlusPlus.core.item.ModItems; +import gtPlusPlus.api.objects.minecraft.ItemPackage; import gtPlusPlus.core.item.base.BaseItemComponent; import gtPlusPlus.core.lib.CORE; import gtPlusPlus.core.recipe.common.CI; import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.math.MathUtils; import gtPlusPlus.core.util.minecraft.FluidUtils; import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.MaterialUtils; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; import net.minecraftforge.fluids.FluidStack; -public class RocketFuels { +public class RocketFuels extends ItemPackage { public static HashSet<String> mValidRocketFuelNames = new HashSet<String>(); public static HashMap<Integer, Fluid> mValidRocketFuels = new HashMap<Integer, Fluid>(); - public static Fluid Kerosene; + public static Fluid Oil_Heavy; + public static Fluid Diesel; + public static Fluid Kerosene; public static Fluid RP1; public static Fluid Nitrogen_Tetroxide; public static Fluid Hydrazine; @@ -45,117 +51,23 @@ public class RocketFuels { public static Item Ammonium_Nitrate_Dust; public static Item Formaldehyde_Catalyst; - - public static void run(){ - - //Create Kerosene - Kerosene = FluidUtils.generateFluidNonMolten("Kerosene", "Kerosene", 500, new short[]{150, 40, 150, 100}, null, null); - - //RP! Focket Fuel - RP1 = FluidUtils.generateFluidNonMolten("RP1Fuel", "RP-1 Rocket Fuel", 500, new short[]{210, 50, 50, 100}, null, null); - - //Create Nitrogen Tetroxide - Nitrogen_Tetroxide = FluidUtils.generateFluidNonMolten("NitrogenTetroxide", "Nitrogen Tetroxide", -11, new short[]{170, 170, 0, 100}, null, null); - - //Create Hydrazine - Hydrazine = FluidUtils.generateFluidNonMolten("Hydrazine", "Hydrazine", 2, new short[]{250, 250, 250, 100}, null, null); - - //Create Monomethylhydrazine - Monomethylhydrazine = FluidUtils.generateFluidNonMolten("Monomethylhydrazine", "Monomethylhydrazine", -52, new short[]{125, 125, 125, 100}, null, null); - - //Create Anthracene - Nitrous_Oxide = FluidUtils.generateFluidNonMolten("NitrousOxide", "Nitrous Oxide", -91, new short[]{255, 255, 255, 100}, null, null); - - //Nos - if (!FluidUtils.doesFluidExist("NitrousOxide")){ - Nitrous_Oxide = FluidUtils.generateFluidNoPrefix("NitrousOxide", "Nitrous Oxide", -91, new short[]{255, 255, 255, 100}); - } - else { - Nitrous_Oxide = FluidUtils.getWildcardFluidStack("NitrousOxide", 1).getFluid(); - if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cellNitrousOxide", 1) == null){ - new BaseItemComponent("NitrousOxide", "Nitrous Oxide", new short[] {10, 10, 175}); - } - } - - //Unsymmetrical_Dimethylhydrazine - if (FluidUtils.getFluidStack("1,1dimethylhydrazine", 1) == null){ - Unsymmetrical_Dimethylhydrazine = FluidUtils.generateFluidNonMolten("UnsymmetricalDimethylhydrazine", "Unsymmetrical Dimethylhydrazine", -57, new short[]{70, 210, 20, 100}, null, null); - } - else { - Unsymmetrical_Dimethylhydrazine = FluidUtils.getFluidStack("1,1dimethylhydrazine", 1000).getFluid(); - } - - //Create Hydrated_Ammonium_Nitrate_Slurry - Hydrated_Ammonium_Nitrate_Slurry = FluidUtils.generateFluidNonMolten("AmmoniumNitrateSlurry", "Hydrated Ammonium Nitrate Slurry", 450, new short[]{150, 75, 150, 100}, null, null); - - //Lithium Hydroperoxide - LiOH + H2O2 → LiOOH + 2 H2O - Ammonium_Nitrate_Dust = ItemUtils.generateSpecialUseDusts("AmmoniumNitrate", "Ammonium Nitrate", "N2H4O3", Utils.rgbtoHexValue(150, 75, 150))[0]; - - //Create Liquid_Oxygen - if (FluidUtils.getFluidStack("LiquidOxygen", 1) == null && FluidUtils.getFluidStack("liquidoxygen", 1) == null){ - Liquid_Oxygen = FluidUtils.generateFluidNonMolten("LiquidOxygen", "Liquid Oxygen", -240, new short[]{75, 75, 220, 100}, null, null); - } - else { - if (FluidUtils.getFluidStack("LiquidOxygen", 1) != null ) { - Liquid_Oxygen = FluidUtils.getFluidStack("LiquidOxygen", 1).getFluid(); - } - else { - Liquid_Oxygen = FluidUtils.getFluidStack("liquidoxygen", 1).getFluid(); - } - if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cellLiquidOxygen", 1) == null){ - new BaseItemComponent("LiquidOxygen", "Liquid Oxygen", new short[] {10, 10, 175}); - } - } - - Formaldehyde = FluidUtils.generateFluidNonMolten("Formaldehyde", "Formaldehyde", -92, new short[]{150, 75, 150, 100}, null, null); - Formaldehyde_Catalyst = ItemUtils.generateSpecialUseDusts("FormaldehydeCatalyst", "Formaldehyde Catalyst", "Fe16V1", Utils.rgbtoHexValue(25, 5, 25))[0]; - - - Unsymmetrical_Dimethylhydrazine_Plus_Nitrogen_Tetroxide = FluidUtils.generateFluidNonMolten("RocketFuelMixA", "H8N4C2O4 Rocket Fuel", -185, new short[]{50, 220, 50, 100}, null, null); - RP1_Plus_Liquid_Oxygen = FluidUtils.generateFluidNonMolten("RocketFuelMixB", "Rp-1 Fuel Mixture", -250, new short[]{250, 50, 50, 100}, null, null); - Monomethylhydrazine_Plus_Nitric_Acid = FluidUtils.generateFluidNonMolten("RocketFuelMixC", "CN3H7O3 Rocket Fuel", -300, new short[]{125, 75, 180, 100}, null, null); - Dense_Hydrazine_Mix = FluidUtils.generateFluidNonMolten("RocketFuelMixD", "Dense Hydrazine Fuel Mixture", -250, new short[]{175, 80, 120, 100}, null, null); - - - - createRecipes(); - - - } - - private static void createRecipes() { - createKerosene(); - createRP1(); - createNitrogenTetroxide(); - createHydrazine(); - createMonomethylhydrazine(); - - if (!CORE.GTNH) { - createLOX(); - } - - - createHydratedAmmoniumNitrateSlurry(); - createAmmoniumNitrateDust(); - createFormaldehyde(); - createFormaldehydeCatalyst(); - createUnsymmetricalDimethylhydrazine(); - - createRocketFuels(); - addRocketFuelsToMap(); - - } - + public static void createKerosene(){ - FluidStack fuelA = FluidUtils.getFluidStack("diesel", 400); - FluidStack fuelB = FluidUtils.getFluidStack("fuel", 400); + + + + FluidStack fuelA = FluidUtils.getFluidStack("diesel", 300); + FluidStack fuelB = FluidUtils.getFluidStack("fuel", 300); + + + if (fuelA != null){ //GT_Values.RA.addDistilleryRecipe(23, fuelA, FluidUtils.getFluidStack(Kerosene, 50), 200, 64, false); - GT_Values.RA.addDistilleryRecipe(CI.getNumberedCircuit(23), fuelA, FluidUtils.getFluidStack(Kerosene, 50), 200, 64, false); + GT_Values.RA.addDistilleryRecipe(CI.getNumberedCircuit(23), fuelA, FluidUtils.getFluidStack(Kerosene, 100), 200, 64, false); } if (fuelA == null && fuelB != null){ //GT_Values.RA.addDistilleryRecipe(23, fuelB, FluidUtils.getFluidStack(Kerosene, 50), 200, 64, false); - GT_Values.RA.addDistilleryRecipe(CI.getNumberedCircuit(23), fuelB, FluidUtils.getFluidStack(Kerosene, 50), 200, 64, false); + GT_Values.RA.addDistilleryRecipe(CI.getNumberedCircuit(23), fuelB, FluidUtils.getFluidStack(Kerosene, 100), 200, 64, false); } } @@ -288,9 +200,9 @@ public class RocketFuels { } - private static void addRocketFuelsToMap() { - AutoMap<Recipe_GT> mRocketFuels = new AutoMap<Recipe_GT>(); - mRocketFuels.put(new Recipe_GT( + private static void addRocketFuelsToMap() { + HashMap<Integer, Recipe_GT> mRocketFuels = new LinkedHashMap<Integer, Recipe_GT>(); + mRocketFuels.put(0, new Recipe_GT( true, new ItemStack[] {}, new ItemStack[] {}, @@ -302,7 +214,7 @@ public class RocketFuels { 0, 256)); //Fuel Value - mRocketFuels.put(new Recipe_GT( + mRocketFuels.put(1, new Recipe_GT( true, new ItemStack[] {}, new ItemStack[] {}, @@ -314,7 +226,7 @@ public class RocketFuels { 0, 512)); //Fuel Value - mRocketFuels.put(new Recipe_GT( + mRocketFuels.put(2, new Recipe_GT( true, new ItemStack[] {}, new ItemStack[] {}, @@ -326,7 +238,7 @@ public class RocketFuels { 0, 768)); //Fuel Value - mRocketFuels.put(new Recipe_GT( + mRocketFuels.put(3, new Recipe_GT( true, new ItemStack[] {}, new ItemStack[] {}, @@ -340,15 +252,15 @@ public class RocketFuels { //Add in default Diesel for the Buggy - mValidRocketFuelNames.add(Materials.Fuel.getFluid(1).getFluid().getName()); - mValidRocketFuels.put(-1, Materials.Fuel.getFluid(1).getFluid()); - - int mID = 0; - for (Recipe_GT r : mRocketFuels) { - if (r != null) { - mValidRocketFuelNames.add(r.mFluidInputs[0].getFluid().getName()); - mValidRocketFuels.put(mID++, r.mFluidInputs[0].getFluid()); - Recipe_GT.Gregtech_Recipe_Map.sRocketFuels.add(r); + mValidRocketFuels.put(-1, Diesel); + + mValidRocketFuelNames.add(FluidRegistry.getFluidName(Diesel)); + for (int mID : mRocketFuels.keySet()) { + Recipe_GT aFuelRecipe = mRocketFuels.get(mID); + if (aFuelRecipe != null) { + mValidRocketFuelNames.add(FluidRegistry.getFluidName(aFuelRecipe.mFluidInputs[0].getFluid())); + mValidRocketFuels.put(mID, aFuelRecipe.mFluidInputs[0].getFluid()); + Recipe_GT.Gregtech_Recipe_Map.sRocketFuels.add(aFuelRecipe); } } @@ -500,6 +412,333 @@ public class RocketFuels { } + @Override + public String errorMessage() { + // TODO Auto-generated method stub + return "Bad Rocket Fuel Science!"; + } + + @Override + public boolean generateRecipes() { + createKerosene(); + createRP1(); + createNitrogenTetroxide(); + createHydrazine(); + createMonomethylhydrazine(); + + if (!CORE.GTNH) { + createLOX(); + } + + + createHydratedAmmoniumNitrateSlurry(); + createAmmoniumNitrateDust(); + createFormaldehyde(); + createFormaldehydeCatalyst(); + createUnsymmetricalDimethylhydrazine(); + + createRocketFuels(); + addRocketFuelsToMap(); + + return true; + } + + @Override + public boolean onLoadComplete(FMLLoadCompleteEvent event) { + + + if (MathUtils.randInt(1, 2) > 0) { + return false; + } + + + Materials aMaterial_Chloramine = MaterialUtils.getMaterial("Chloramine"); + Materials aMaterial_Dimethylamine = MaterialUtils.getMaterial("Dimethylamine"); + Materials aMaterial_DilutedHydrochloricAcid = MaterialUtils.getMaterial("DilutedHydrochloricAcid"); + Materials aMaterial_NitrogenDioxide = MaterialUtils.getMaterial("NitrogenDioxide"); + Materials aMaterial_DinitrogenTetroxide = MaterialUtils.getMaterial("DinitrogenTetroxide"); + Materials aMaterial_Dimethylhydrazine = MaterialUtils.getMaterial("Dimethylhydrazine"); + + Materials aMaterial_Oxygen = Materials.Oxygen; + Materials aMaterial_Water = Materials.Water; + Materials aMaterial_HypochlorousAcid = MaterialUtils.getMaterial("HypochlorousAcid"); + Materials aMaterial_Ammonia = MaterialUtils.getMaterial("Ammonia"); + Materials aMaterial_Methanol = MaterialUtils.getMaterial("Methanol"); + + if (aMaterial_Chloramine == null || aMaterial_Dimethylamine == null || aMaterial_DilutedHydrochloricAcid == null + || aMaterial_Dimethylhydrazine == null || aMaterial_NitrogenDioxide == null || aMaterial_DinitrogenTetroxide == null + || aMaterial_HypochlorousAcid == null || aMaterial_Ammonia == null || aMaterial_Methanol == null) { + return false; + } + + + ItemStack aCellEmpty = CI.emptyCells(1); + ItemStack aCellWater = aMaterial_Water.getCells(1); + ItemStack aCellOxygen = aMaterial_Oxygen.getCells(1); + ItemStack aCellChloramine = aMaterial_Chloramine.getCells(1); + ItemStack aCellDimethylamine = aMaterial_Dimethylamine.getCells(1); + ItemStack aCellDilutedHydrochloricAcid = aMaterial_DilutedHydrochloricAcid.getCells(1); + ItemStack aCellNitrogenDioxide = aMaterial_NitrogenDioxide.getCells(1); + ItemStack aCellDinitrogenTetroxide = aMaterial_DinitrogenTetroxide.getCells(1); + ItemStack aCellDimethylhydrazine = aMaterial_Dimethylhydrazine.getCells(1); + + + + + + + GT_Recipe aChemReactor_1 = new Recipe_GT( + true, //Optimise + new ItemStack[] {}, //I + new ItemStack[] {}, //O + null, //Special + new int[] {}, //Chance + new FluidStack[] {}, //I + new FluidStack[] {}, //O + 0, //Dura + 0, //Eu + 0); //Special + + GT_Recipe aChemReactor_2 = new Recipe_GT( + true, //Optimise + new ItemStack[] {}, //I + new ItemStack[] {}, //O + null, //Special + new int[] {}, //Chance + new FluidStack[] {}, //I + new FluidStack[] {}, //O + 0, //Dura + 0, //Eu + 0); //Special + + + + + GT_Recipe aChemReactor_Basic_1 = new Recipe_GT( + true, //Optimise + new ItemStack[] {}, //I + new ItemStack[] {}, //O + null, //Special + new int[] {}, //Chance + new FluidStack[] {}, //I + new FluidStack[] {}, //O + 0, //Dura + 0, //Eu + 0); //Special + + GT_Recipe aChemReactor_Basic_2 = new Recipe_GT( + true, //Optimise + new ItemStack[] {}, //I + new ItemStack[] {}, //O + null, //Special + new int[] {}, //Chance + new FluidStack[] {}, //I + new FluidStack[] {}, //O + 0, //Dura + 0, //Eu + 0); //Special + + GT_Recipe aChemReactor_Basic_3 = new Recipe_GT( + true, //Optimise + new ItemStack[] {}, //I + new ItemStack[] {}, //O + null, //Special + new int[] {}, //Chance + new FluidStack[] {}, //I + new FluidStack[] {}, //O + 0, //Dura + 0, //Eu + 0); //Special + + GT_Recipe aChemReactor_Basic_4 = new Recipe_GT( + true, //Optimise + new ItemStack[] {}, //I + new ItemStack[] {}, //O + null, //Special + new int[] {}, //Chance + new FluidStack[] {}, //I + new FluidStack[] {}, //O + 0, //Dura + 0, //Eu + 0); //Special + + + + + + + + + + + + + + GT_Recipe aChemReactor_Adv_1 = new Recipe_GT( + true, //Optimise + new ItemStack[] {}, //I + new ItemStack[] {}, //O + null, //Special + new int[] {}, //Chance + new FluidStack[] {}, //I + new FluidStack[] {}, //O + 0, //Dura + 0, //Eu + 0); //Special + + GT_Recipe aChemReactor_Adv_2 = new Recipe_GT( + true, //Optimise + new ItemStack[] {}, //I + new ItemStack[] {}, //O + null, //Special + new int[] {}, //Chance + new FluidStack[] {}, //I + new FluidStack[] {}, //O + 0, //Dura + 0, //Eu + 0); //Special + + + + + //RecipeUtils.removeGtRecipe(aChemReactor_Basic_1, GT_Recipe.GT_Recipe_Map.sChemicalRecipes); + //RecipeUtils.removeGtRecipe(aChemReactor_Basic_1, GT_Recipe.GT_Recipe_Map.sChemicalRecipes); + //RecipeUtils.removeGtRecipe(aChemReactor_Basic_1, GT_Recipe.GT_Recipe_Map.sChemicalRecipes); + //RecipeUtils.removeGtRecipe(aChemReactor_Basic_1, GT_Recipe.GT_Recipe_Map.sChemicalRecipes); + + + + + + + /* GT_Values.RA.addChemicalRecipe( Materials.Chloramine.getCells(2), GT_Utility.getIntegratedCircuit(1), Materials.Dimethylamine.getGas(5000), Materials.Dimethylhydrazine.getFluid(6000), Materials.DilutedHydrochloricAcid.getCells(1), Materials.Empty.getCells(1), 960, 480); + GT_Values.RA.addChemicalRecipe( Materials.Dimethylamine.getCells(5), GT_Utility.getIntegratedCircuit(1), Materials.Chloramine.getFluid(2000), Materials.Dimethylhydrazine.getFluid(6000), Materials.DilutedHydrochloricAcid.getCells(1), Materials.Empty.getCells(4), 960, 480); + GT_Values.RA.addChemicalRecipeForBasicMachineOnly(Materials.Chloramine.getCells(2), Materials.Empty.getCells(4), Materials.Dimethylamine.getGas(5000), Materials.DilutedHydrochloricAcid.getFluid(1000), Materials.Dimethylhydrazine.getCells(6), GT_Values.NI, 960, 480); + GT_Values.RA.addChemicalRecipeForBasicMachineOnly(Materials.Dimethylamine.getCells(5), Materials.Empty.getCells(1), Materials.Chloramine.getFluid(2000), Materials.DilutedHydrochloricAcid.getFluid(1000), Materials.Dimethylhydrazine.getCells(6), GT_Values.NI, 960, 480); + GT_Values.RA.addChemicalRecipeForBasicMachineOnly(Materials.Dimethylamine.getCells(5), Materials.Chloramine.getCells(2), Materials.Chloramine.getFluid(2000), Materials.DilutedHydrochloricAcid.getFluid(1000), Materials.Dimethylhydrazine.getCells(6), Materials.DilutedHydrochloricAcid.getCells(1), 960, 480); + GT_Values.RA.addMultiblockChemicalRecipe(new ItemStack[]{GT_Utility.getIntegratedCircuit(24)}, new FluidStack[]{Materials.HypochlorousAcid.getFluid(3000), Materials.Ammonia.getGas(8000), Materials.Methanol.getFluid(12000)}, new FluidStack[]{Materials.Dimethylhydrazine.getFluid(12000), Materials.DilutedHydrochloricAcid.getFluid(2000), Materials.Water.getFluid(9000)}, null, 1040, 480); + + GT_Values.RA.addChemicalRecipe(GT_Utility.getIntegratedCircuit(2), GT_Values.NI, Materials.NitrogenDioxide.getGas(1000), Materials.DinitrogenTetroxide.getGas(1000), GT_Values.NI, 640); + GT_Values.RA.addChemicalRecipe(Materials.NitrogenDioxide.getCells(1), GT_Utility.getIntegratedCircuit(2), GT_Values.NF, Materials.DinitrogenTetroxide.getGas(1000), Materials.Empty.getCells(1), 640); + GT_Values.RA.addChemicalRecipe(Materials.NitrogenDioxide.getCells(1), GT_Utility.getIntegratedCircuit(12), GT_Values.NF, GT_Values.NF, Materials.DinitrogenTetroxide.getCells(1), 640); + GT_Values.RA.addMultiblockChemicalRecipe(new ItemStack[]{GT_Utility.getIntegratedCircuit(23)}, new FluidStack[]{Materials.Ammonia.getGas(8000), Materials.Oxygen.getGas(7000)}, new FluidStack[]{Materials.DinitrogenTetroxide.getGas(6000), Materials.Water.getFluid(9000)}, null, 480, 30); + GT_Values.RA.addMultiblockChemicalRecipe(new ItemStack[]{GT_Utility.getIntegratedCircuit(23)}, new FluidStack[]{Materials.Nitrogen.getGas(2000), Materials.Hydrogen.getGas(6000), Materials.Oxygen.getGas(7000)}, new FluidStack[]{Materials.DinitrogenTetroxide.getGas(6000), Materials.Water.getFluid(9000)}, null, 1100, 480); + + GT_Values.RA.addMixerRecipe(Materials.Dimethylhydrazine.getCells(1), GT_Values.NI, GT_Values.NI, GT_Values.NI, Materials.DinitrogenTetroxide.getGas(1000), new FluidStack(ItemList.sRocketFuel, 2000), Materials.Empty.getCells(1), 60, 16); + GT_Values.RA.addMixerRecipe(Materials.DinitrogenTetroxide.getCells(1), GT_Values.NI, GT_Values.NI, GT_Values.NI, Materials.Dimethylhydrazine.getFluid(1000), new FluidStack(ItemList.sRocketFuel, 2000), Materials.Empty.getCells(1), 60, 16); + GT_Values.RA.addMixerRecipe(Materials.Dimethylhydrazine.getCells(2), GT_Values.NI, GT_Values.NI, GT_Values.NI, Materials.Oxygen.getGas(1000), new FluidStack(ItemList.sRocketFuel, 3000), Materials.Empty.getCells(2), 60, 16); + GT_Values.RA.addMixerRecipe(Materials.Oxygen.getCells(1), GT_Values.NI, GT_Values.NI, GT_Values.NI, Materials.Dimethylhydrazine.getFluid(2000), new FluidStack(ItemList.sRocketFuel, 3000), Materials.Empty.getCells(1), 60, 16); + + + */ + + + + + + + + + + //Get Rocket Fuel + + //Find recipes using default values + + //Remove + + //Rebake map + + return true; + }; + + @Override + public void items() { + Formaldehyde_Catalyst = ItemUtils.generateSpecialUseDusts("FormaldehydeCatalyst", "Formaldehyde Catalyst", "Fe16V1", Utils.rgbtoHexValue(25, 5, 25))[0]; + } + + @Override + public void blocks() { + } + + @Override + public void fluids() { + + //Register default fluids + Diesel = MaterialUtils.getMaterial("Fuel", "Diesel").getFluid(1).getFluid(); + Oil_Heavy = MaterialUtils.getMaterial("OilHeavy", "Oil").getFluid(1).getFluid(); + + + //Create Kerosene + Kerosene = FluidUtils.generateFluidNonMolten("Kerosene", "Kerosene", 500, new short[]{150, 40, 150, 100}, null, null); + CoalTar.Coal_Oil = Kerosene; + + //RP! Focket Fuel + RP1 = FluidUtils.generateFluidNonMolten("RP1Fuel", "RP-1 Rocket Fuel", 500, new short[]{210, 50, 50, 100}, null, null); + + //Create Nitrogen Tetroxide + Nitrogen_Tetroxide = FluidUtils.generateFluidNonMolten("NitrogenTetroxide", "Nitrogen Tetroxide", -11, new short[]{170, 170, 0, 100}, null, null); + + //Create Hydrazine + Hydrazine = FluidUtils.generateFluidNonMolten("Hydrazine", "Hydrazine", 2, new short[]{250, 250, 250, 100}, null, null); + + //Create Monomethylhydrazine + Monomethylhydrazine = FluidUtils.generateFluidNonMolten("Monomethylhydrazine", "Monomethylhydrazine", -52, new short[]{125, 125, 125, 100}, null, null); + + //Create Anthracene + Nitrous_Oxide = FluidUtils.generateFluidNonMolten("NitrousOxide", "Nitrous Oxide", -91, new short[]{255, 255, 255, 100}, null, null); + + //Nos + if (!FluidUtils.doesFluidExist("NitrousOxide")){ + Nitrous_Oxide = FluidUtils.generateFluidNoPrefix("NitrousOxide", "Nitrous Oxide", -91, new short[]{255, 255, 255, 100}); + } + else { + Nitrous_Oxide = FluidUtils.getWildcardFluidStack("NitrousOxide", 1).getFluid(); + if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cellNitrousOxide", 1) == null){ + new BaseItemComponent("NitrousOxide", "Nitrous Oxide", new short[] {10, 10, 175}); + } + } + + //Unsymmetrical_Dimethylhydrazine + if (FluidUtils.getFluidStack("1,1dimethylhydrazine", 1) == null){ + Unsymmetrical_Dimethylhydrazine = FluidUtils.generateFluidNonMolten("UnsymmetricalDimethylhydrazine", "Unsymmetrical Dimethylhydrazine", -57, new short[]{70, 210, 20, 100}, null, null); + } + else { + Unsymmetrical_Dimethylhydrazine = FluidUtils.getFluidStack("1,1dimethylhydrazine", 1000).getFluid(); + } + + //Create Hydrated_Ammonium_Nitrate_Slurry + Hydrated_Ammonium_Nitrate_Slurry = FluidUtils.generateFluidNonMolten("AmmoniumNitrateSlurry", "Hydrated Ammonium Nitrate Slurry", 450, new short[]{150, 75, 150, 100}, null, null); + + //Lithium Hydroperoxide - LiOH + H2O2 → LiOOH + 2 H2O + Ammonium_Nitrate_Dust = ItemUtils.generateSpecialUseDusts("AmmoniumNitrate", "Ammonium Nitrate", "N2H4O3", Utils.rgbtoHexValue(150, 75, 150))[0]; + + //Create Liquid_Oxygen + if (FluidUtils.getFluidStack("LiquidOxygen", 1) == null && FluidUtils.getFluidStack("liquidoxygen", 1) == null){ + Liquid_Oxygen = FluidUtils.generateFluidNonMolten("LiquidOxygen", "Liquid Oxygen", -240, new short[]{75, 75, 220, 100}, null, null); + } + else { + if (FluidUtils.getFluidStack("LiquidOxygen", 1) != null ) { + Liquid_Oxygen = FluidUtils.getFluidStack("LiquidOxygen", 1).getFluid(); + } + else { + Liquid_Oxygen = FluidUtils.getFluidStack("liquidoxygen", 1).getFluid(); + } + if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cellLiquidOxygen", 1) == null){ + new BaseItemComponent("LiquidOxygen", "Liquid Oxygen", new short[] {10, 10, 175}); + } + } + + + Formaldehyde = FluidUtils.generateFluidNonMolten("Formaldehyde", "Formaldehyde", -92, new short[]{150, 75, 150, 100}, null, null); + + Unsymmetrical_Dimethylhydrazine_Plus_Nitrogen_Tetroxide = FluidUtils.generateFluidNonMolten("RocketFuelMixA", "H8N4C2O4 Rocket Fuel", -185, new short[]{50, 220, 50, 100}, null, null); + RP1_Plus_Liquid_Oxygen = FluidUtils.generateFluidNonMolten("RocketFuelMixB", "Rp-1 Fuel Mixture", -250, new short[]{250, 50, 50, 100}, null, null); + Monomethylhydrazine_Plus_Nitric_Acid = FluidUtils.generateFluidNonMolten("RocketFuelMixC", "CN3H7O3 Rocket Fuel", -300, new short[]{125, 75, 180, 100}, null, null); + Dense_Hydrazine_Mix = FluidUtils.generateFluidNonMolten("RocketFuelMixD", "Dense Hydrazine Fuel Mixture", -250, new short[]{175, 80, 120, 100}, null, null); + + + } + } diff --git a/src/Java/gtPlusPlus/core/item/general/ItemControlCore.java b/src/Java/gtPlusPlus/core/item/general/ItemControlCore.java index eb22f8fa07..5ef72b6f17 100644 --- a/src/Java/gtPlusPlus/core/item/general/ItemControlCore.java +++ b/src/Java/gtPlusPlus/core/item/general/ItemControlCore.java @@ -17,7 +17,7 @@ import gtPlusPlus.core.lib.CORE; public class ItemControlCore extends Item { - public IIcon[] icons = new IIcon[10]; + public static IIcon[] icons = new IIcon[10]; public ItemControlCore() { super(); @@ -31,16 +31,16 @@ public class ItemControlCore extends Item { @Override public void registerIcons(IIconRegister reg) { - this.icons[0] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_0"); - this.icons[1] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_1"); - this.icons[2] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_2"); - this.icons[3] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_3"); - this.icons[4] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_4"); - this.icons[5] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_5"); - this.icons[6] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_6"); - this.icons[7] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_7"); - this.icons[8] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_8"); - this.icons[9] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_9"); + icons[0] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_0"); + icons[1] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_1"); + icons[2] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_2"); + icons[3] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_3"); + icons[4] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_4"); + icons[5] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_5"); + icons[6] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_6"); + icons[7] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_7"); + icons[8] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_8"); + icons[9] = reg.registerIcon(CORE.MODID + ":" + "controlcore/Core_9"); } @Override diff --git a/src/Java/gtPlusPlus/core/item/general/throwables/ItemThrowableBomb.java b/src/Java/gtPlusPlus/core/item/general/throwables/ItemThrowableBomb.java new file mode 100644 index 0000000000..9467c3a58c --- /dev/null +++ b/src/Java/gtPlusPlus/core/item/general/throwables/ItemThrowableBomb.java @@ -0,0 +1,123 @@ +package gtPlusPlus.core.item.general.throwables; + +import java.util.List; + +import gregtech.api.enums.ItemList; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.creative.AddToCreativeTab; +import gtPlusPlus.core.entity.projectile.EntityThrowableBomb; +import gtPlusPlus.core.item.ModItems; +import gtPlusPlus.core.item.base.CoreItem; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.NBTUtils; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.item.EnumRarity; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; + +public class ItemThrowableBomb extends CoreItem { + + private static AutoMap<ItemStack> mLighters = new AutoMap<ItemStack>(); + public static IIcon[] icons = new IIcon[10]; + + public ItemThrowableBomb() { + super("gtpp.throwable.bomb", "Bomb", AddToCreativeTab.tabMisc, 16, 0, new String[] {"Just like Bomberman", "Have a fire source in inventory to prime"}, EnumRarity.uncommon, EnumChatFormatting.GRAY, false, null); + this.setHasSubtypes(true); + } + + @Override + public ItemStack onItemRightClick(ItemStack item, World world, EntityPlayer player) { + + if (mLighters.isEmpty()) { + mLighters.put(ItemUtils.getSimpleStack(Items.flint_and_steel)); + mLighters.put(ItemList.Tool_Lighter_Invar_Full.get(1)); + mLighters.put(ItemList.Tool_Lighter_Invar_Used.get(1)); + mLighters.put(ItemList.Tool_Lighter_Platinum_Full.get(1)); + mLighters.put(ItemList.Tool_Lighter_Platinum_Used.get(1)); + mLighters.put(ItemUtils.getSimpleStack(ModItems.itemBasicFireMaker)); + } + + //Unlit + if (item.getItemDamage() == 0) { + boolean hasLighter = false; + for (ItemStack aPlaySlot : player.inventory.mainInventory) { + if (aPlaySlot != null) { + for (ItemStack aLighter : mLighters) { + if (GT_Utility.areStacksEqual(aPlaySlot, aLighter)) { + hasLighter = true; + break; + } + } + } + } + if (hasLighter) { + item.setItemDamage(1); + } + } + //Lit + else if (item.getItemDamage() == 1) { + if (!player.capabilities.isCreativeMode) { + --item.stackSize; + } + world.playSoundAtEntity(player, "random.bow", 0.5F, 0.4F / (itemRand.nextFloat() * 0.4F + 0.8F)); + if (!world.isRemote) { + world.spawnEntityInWorld(new EntityThrowableBomb(world, player)); + } + /*if (item.stackSize <= 0) { + item = null; + }*/ + } + return item; + } + + + + @Override + public void registerIcons(IIconRegister reg) { + icons[0] = reg.registerIcon(CORE.MODID + ":" + "bomb"); + icons[1] = reg.registerIcon(CORE.MODID + ":" + "bomb_lit"); + } + + @Override + public IIcon getIconFromDamage(int meta) { + return this.icons[meta]; + } + + @SuppressWarnings({ "unchecked" }) + @Override + public void getSubItems(Item item, CreativeTabs tab, List list) { + for (int i = 0; i < 2; i ++) { + list.add(new ItemStack(item, 1, i)); + } + } + + @Override + public void addInformation(ItemStack stack, EntityPlayer aPlayer, List list, boolean bool) { + String aLitStatus = "unlit"; + if (stack.getItemDamage() == 0) { + aLitStatus = EnumChatFormatting.BLUE+"Unlit"; + } + else if (stack.getItemDamage() == 1) { + aLitStatus = EnumChatFormatting.RED+"Lit"; + } + list.add(EnumChatFormatting.GOLD+"Fuse Status: "+aLitStatus); + super.addInformation(stack, aPlayer, list, bool); + } + + @Override + public String getItemStackDisplayName(ItemStack p_77653_1_) { + // TODO Auto-generated method stub + return super.getItemStackDisplayName(p_77653_1_); + } + + + +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/core/item/init/ItemsFoods.java b/src/Java/gtPlusPlus/core/item/init/ItemsFoods.java index 77a06edac2..94ebb3ffcb 100644 --- a/src/Java/gtPlusPlus/core/item/init/ItemsFoods.java +++ b/src/Java/gtPlusPlus/core/item/init/ItemsFoods.java @@ -21,24 +21,24 @@ public class ItemsFoods { //Raisin Bread ModItems.itemIngotRaisinBread = new BaseItemFood("itemIngotRaisinBread", "Raisin Bread", 3, 1.5f, false, new PotionEffect(Potion.weakness.id, 40, 1)).setAlwaysEdible(); - GT_OreDictUnificator.registerOre("foodRaisinBread", ItemUtils.getItemStack(CORE.MODID+":itemIngotRaisinBread", 1)); + GT_OreDictUnificator.registerOre("foodRaisinBread", ItemUtils.getItemStackFromFQRN(CORE.MODID+":itemIngotRaisinBread", 1)); //Hot Raisin Bread ModItems.itemHotIngotRaisinBread = new BaseItemHotFood("itemHotIngotRaisinBread", 1, 0.5f, "Raisin Bread", 120, ModItems.itemIngotRaisinBread); - GT_OreDictUnificator.registerOre("foodHotRaisinBread", ItemUtils.getItemStack(CORE.MODID+":itemHotIngotRaisinBread", 1)); + GT_OreDictUnificator.registerOre("foodHotRaisinBread", ItemUtils.getItemStackFromFQRN(CORE.MODID+":itemHotIngotRaisinBread", 1)); //Raisin Bread ModItems.itemFoodRaisinToast = new BaseItemFood("itemFoodRaisinToast", "Raisin Toast", 1, 0.5f, false).setAlwaysEdible(); - GT_OreDictUnificator.registerOre("foodRaisinToast", ItemUtils.getItemStack(CORE.MODID+":itemFoodRaisinToast", 1)); + GT_OreDictUnificator.registerOre("foodRaisinToast", ItemUtils.getItemStackFromFQRN(CORE.MODID+":itemFoodRaisinToast", 1)); //Hot Raisin Bread ModItems.itemHotFoodRaisinToast = new BaseItemHotFood("itemHotFoodRaisinToast", 1, 0.5f, "Raisin Toast", 20, ModItems.itemFoodRaisinToast); - GT_OreDictUnificator.registerOre("foodHotRaisinToast", ItemUtils.getItemStack(CORE.MODID+":itemHotFoodRaisinToast", 1)); + GT_OreDictUnificator.registerOre("foodHotRaisinToast", ItemUtils.getItemStackFromFQRN(CORE.MODID+":itemHotFoodRaisinToast", 1)); //Raisin Bread ModItems.itemFoodCurriedSausages = new BaseItemFood("itemFoodCurriedSausages", "Curried Sausages", 5, 2f, false); - GT_OreDictUnificator.registerOre("foodCurriedSausages", ItemUtils.getItemStack(CORE.MODID+":itemFoodCurriedSausages", 1)); + GT_OreDictUnificator.registerOre("foodCurriedSausages", ItemUtils.getItemStackFromFQRN(CORE.MODID+":itemFoodCurriedSausages", 1)); //Hot Raisin Bread ModItems.itemHotFoodCurriedSausages = new BaseItemHotFood("itemHotFoodCurriedSausages", 1, 0.5f, "Curried Sausages", 240, ModItems.itemFoodCurriedSausages); - GT_OreDictUnificator.registerOre("foodHotCurriedSausages", ItemUtils.getItemStack(CORE.MODID+":itemHotFoodCurriedSausages", 1)); + GT_OreDictUnificator.registerOre("foodHotCurriedSausages", ItemUtils.getItemStackFromFQRN(CORE.MODID+":itemHotFoodCurriedSausages", 1)); } diff --git a/src/Java/gtPlusPlus/core/item/tool/misc/GregtechPump.java b/src/Java/gtPlusPlus/core/item/tool/misc/GregtechPump.java index 721ebc8c24..4616ab0aa0 100644 --- a/src/Java/gtPlusPlus/core/item/tool/misc/GregtechPump.java +++ b/src/Java/gtPlusPlus/core/item/tool/misc/GregtechPump.java @@ -19,6 +19,7 @@ import gregtech.api.interfaces.IItemBehaviour; import gregtech.api.interfaces.IItemContainer; import gregtech.api.interfaces.metatileentity.IMetaTileEntity; import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine; import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicTank; import gregtech.api.objects.ItemData; import gregtech.api.util.GT_LanguageManager; @@ -110,8 +111,8 @@ public class GregtechPump extends Item implements ISpecialElectricItem, IElectri aPumpName, // Name aEuMax, // Eu Storage (short) aTier, // Tier - "Can be used to remove fluids from GT machine input slots.", // Tooltip - EnumRarity.common, // Rarity + "Can be used to remove fluids from GT machine input & output slots.", // Tooltip + aTier <= 0 ? EnumRarity.common : aTier == 1 ? EnumRarity.uncommon : aTier == 2 ? EnumRarity.rare : aTier == 3 ? EnumRarity.epic : EnumRarity.common, // Rarity EnumChatFormatting.GRAY, // Desc colour false // Effect? ); @@ -183,7 +184,7 @@ public class GregtechPump extends Item implements ISpecialElectricItem, IElectri return false; } - @SuppressWarnings({ "unchecked", "rawtypes" }) + @SuppressWarnings({ "unchecked" }) @Override public void addInformation(final ItemStack aStack, final EntityPlayer aPlayer, List aList, final boolean aF3_H) { // aList.add("Meta: "+(aStack.getItemDamage()-mOffset)); @@ -498,7 +499,7 @@ public class GregtechPump extends Item implements ISpecialElectricItem, IElectri return this; } - @SuppressWarnings({ "rawtypes", "unchecked" }) + @SuppressWarnings({ "unchecked" }) @Override @SideOnly(Side.CLIENT) public void getSubItems(final Item var1, final CreativeTabs aCreativeTab, final List aList) { @@ -970,9 +971,10 @@ public class GregtechPump extends Item implements ISpecialElectricItem, IElectri if ((tTileEntity instanceof IGregTechTileEntity)) { return this.drainTankGT(tTileEntity, aStack, aWorld, aPlayer, aX, aY, aZ); } - /*else if ((tTileEntity instanceof IFluidTank || tTileEntity instanceof IFluidHandler)) { + //Try support Standard Fluid Tanks too (May disable if dupes appear again) + else if ((tTileEntity instanceof IFluidTank || tTileEntity instanceof IFluidHandler)) { return this.drainIFluidTank(tTileEntity, aStack, aWorld, aPlayer, aX, aY, aZ); - }*/ + } } } } @@ -1097,7 +1099,7 @@ public class GregtechPump extends Item implements ISpecialElectricItem, IElectri FluidStack f = aTileEntity.getFluid(); Logger.WARNING("Returning Fluid stack from tile. Found: " + (f != null ? f.getLocalizedName() + " - " + f.amount + "L" : "Nothing")); - return f.copy(); + return f; } public FluidStack getStoredFluidOfVanillaTank(IFluidHandler aTileEntity) { @@ -1128,7 +1130,7 @@ public class GregtechPump extends Item implements ISpecialElectricItem, IElectri FluidStack f = ((IFluidTank) aTileEntity).getFluid(); if (aSetFluid == null) { aSetFluid = f; - aSetFluid.amount = 0; + aSetFluid.amount = f.amount; } int toDrain = (f.amount - aSetFluid.amount); FluidStack newStack; @@ -1146,44 +1148,48 @@ public class GregtechPump extends Item implements ISpecialElectricItem, IElectri return false; } } - else { - Logger.WARNING("Tile Was instanceof IFluidHandler."); - FluidStack containedStack = null; - if ((IFluidHandler) aTileEntity != null) { - FluidTankInfo[] a1 = (((IFluidHandler) aTileEntity).getTankInfo(ForgeDirection.UNKNOWN)); - if (a1 != null) { - if (a1[0] != null) { - Logger.WARNING("Found Fluid in Tank."); - containedStack = a1[0].fluid; - } - } + else { + + //Rewrite Fluid handling for Vanilla type tanks + if (!IFluidHandler.class.isInstance(aTileEntity)) { + Logger.WARNING("Tile Was not an instance of IFluidHandler."); + return false; } - if (containedStack != null) { - if (aSetFluid == null) { - aSetFluid = containedStack; - aSetFluid.amount = 0; - } - int toDrain = (containedStack.amount - aSetFluid.amount); - Logger.WARNING("Found "+containedStack.amount+"L of "+containedStack.getLocalizedName()+". Trying to drain "+toDrain+"L."); - FluidStack newStack; - if (toDrain <= 0) { - Logger.WARNING("Draining Nothing"); - newStack = containedStack; - } else { - Logger.WARNING("Draining Something"); - newStack = ((IFluidTank) aTileEntity).drain(toDrain, true); + + + IFluidHandler aTank = (IFluidHandler) aTileEntity; + FluidStack aTankContents = null; + FluidTankInfo[] a1 = aTank.getTankInfo(ForgeDirection.UNKNOWN); + if (a1 != null) { + if (a1[0] != null) { + aTankContents = a1[0].fluid; + Logger.WARNING("Found Fluid in Tank. "+aTankContents.getLocalizedName()+" - "+aTankContents.amount); } - - if (newStack.isFluidEqual(aSetFluid) && newStack.amount == aSetFluid.amount) { - Logger.WARNING("Removed fluid from vanilla IFluidHandler successfully."); + } + if (aSetFluid == null) { + Logger.WARNING("Setting fluid to tank contents, as we're going to empty it totally."); + aSetFluid = aTankContents.copy(); + } + else { + Logger.WARNING("Setting fluid to tank contents, as we're going to empty it totally."); + } + Logger.WARNING("Tile Was instance of IFluidHandler. Trying to Drain "+aSetFluid.getLocalizedName()+" - "+aSetFluid.amount); + + if (a1 == null || aTankContents == null) { + Logger.WARNING("Tank is empty."); + return false; + } + //Found some Fluid in the tank + else { + FluidStack aDrainedStack = aTank.drain(ForgeDirection.UNKNOWN, aSetFluid, true); + if (aDrainedStack.isFluidStackIdentical(aSetFluid)) { + Logger.WARNING("Drained!"); return true; - } else { - Logger.WARNING("Failed trying to remove fluid from vanilla IFluidHandler."); - return false; } - } else { - Logger.WARNING("Could not drain vanilla tank, IFluidHandler claims there is no fluid."); - return false; + else { + Logger.WARNING("Partially Drained! This is probably an error."); + return true; + } } } } else { @@ -1216,9 +1222,36 @@ public class GregtechPump extends Item implements ISpecialElectricItem, IElectri public FluidStack getStoredFluidOfGTMachine(GT_MetaTileEntity_BasicTank aTileEntity) { FluidStack f = aTileEntity.mFluid; + + //Let's see if this machine has output fluid too + if (f == null) { + Logger.WARNING("Could not find any input fluid, checking output if possible."); + if (aTileEntity instanceof GT_MetaTileEntity_BasicMachine) { + GT_MetaTileEntity_BasicMachine g = (GT_MetaTileEntity_BasicMachine) aTileEntity; + Logger.WARNING("Tile is a Basic Machine of some sort - "+g.mNEIName); + if (g != null) { + f = g.mOutputFluid; + if (f != null) { + Logger.WARNING("Found output fluid! "+f.getLocalizedName()); + } + else { + Logger.WARNING("Did not find anything!"); + f = g.getFluid(); + if (f != null) { + Logger.WARNING("Found fluid! "+f.getLocalizedName()); + } + else { + Logger.WARNING("Did not find anything!"); + f = g.getFluid(); + } + } + } + } + } + Logger.WARNING("Returning Fluid stack from tile. Found: " + (f != null ? f.getLocalizedName() + " - " + f.amount + "L" : "Nothing")); - return f.copy(); + return f; } public boolean setStoredFluidOfGTMachine(IGregTechTileEntity aTileEntity, FluidStack aSetFluid) { @@ -1240,6 +1273,12 @@ public class GregtechPump extends Item implements ISpecialElectricItem, IElectri public boolean setStoredFluidOfGTMachine(GT_MetaTileEntity_BasicTank aTileEntity, FluidStack aSetFluid) { try { + + //Try Handle Outputs First + if (aTileEntity.setDrainableStack(aSetFluid) != null) { + return true; + } + aTileEntity.mFluid = aSetFluid; boolean b = aTileEntity.mFluid == aSetFluid; Logger.WARNING("Trying to set Tile's tank. - Behaviour Class. [3] " + b); diff --git a/src/Java/gtPlusPlus/core/lib/CORE.java b/src/Java/gtPlusPlus/core/lib/CORE.java index 1f82e1cd17..632378987a 100644 --- a/src/Java/gtPlusPlus/core/lib/CORE.java +++ b/src/Java/gtPlusPlus/core/lib/CORE.java @@ -9,7 +9,6 @@ import gregtech.api.GregTech_API; import gtPlusPlus.api.objects.data.Pair; import gtPlusPlus.api.objects.random.XSTR; import gtPlusPlus.core.util.Utils; -import gtPlusPlus.core.util.minecraft.gregtech.recipehandlers.GregtechRecipe; import gtPlusPlus.core.util.sys.GeoUtils; import gtPlusPlus.core.util.sys.NetworkUtils; import gtPlusPlus.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials; @@ -52,7 +51,7 @@ public class CORE { public static final String name = "GT++"; public static final String MODID = "miscutils"; - public static final String VERSION = "1.7.02.89-debug"; + public static final String VERSION = "1.7.02.99-pre"; public static String MASTER_VERSION = NetworkUtils.getContentFromURL("https://raw.githubusercontent.com/draknyte1/GTplusplus/master/Recommended.txt").toLowerCase(); public static String USER_COUNTRY = GeoUtils.determineUsersCountry(); public static boolean isModUpToDate = Utils.isModUpToDate(); @@ -203,7 +202,7 @@ public class CORE { public static boolean disableIC2Recipes = false; public static boolean enableAlternativeDivisionSigilRecipe = false; public static int boilerSteamPerSecond = 750; - public static boolean requireControlCores = true; + public static final boolean requireControlCores = false; //Feature Related public static boolean enableCustomCapes = false; diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java b/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java index 37c7fef1db..a4dc366aee 100644 --- a/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java +++ b/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java @@ -18,6 +18,7 @@ import gtPlusPlus.api.objects.Logger; import gtPlusPlus.core.block.ModBlocks; import gtPlusPlus.core.item.ModItems; import gtPlusPlus.core.item.chemistry.IonParticles; +import gtPlusPlus.core.item.chemistry.RocketFuels; import gtPlusPlus.core.item.crafting.ItemDummyResearch; import gtPlusPlus.core.item.crafting.ItemDummyResearch.ASSEMBLY_LINE_RESEARCH; import gtPlusPlus.core.lib.CORE; @@ -85,10 +86,34 @@ public class RECIPES_GREGTECH { breweryRecipes(); laserEngraverRecipes(); assemblyLineRecipes(); + latheRecipes(); + vacuumFreezerRecipes(); addFuels(); } + private static void vacuumFreezerRecipes() { + GT_Values.RA.addVacuumFreezerRecipe(GregtechItemList.Bomb_Cast_Molten.get(1), GregtechItemList.Bomb_Cast_Set.get(1), 20 * 30); + } + + private static void latheRecipes() { + + GT_Values.RA.addLatheRecipe( + ALLOY.EGLIN_STEEL.getBlock(1), + GregtechItemList.Bomb_Cast_Mold.get(1), + null, + 20 * 60 * 15, + 120); + + GT_Values.RA.addLatheRecipe( + GregtechItemList.Bomb_Cast_Set.get(1), + GregtechItemList.Bomb_Cast_Broken.get(2), + ItemUtils.getSimpleStack(ModItems.itemBombCasing, 2), + 20 * 60 * 5, + 30); + + } + private static void fusionRecipes() { /** @@ -326,7 +351,7 @@ public class RECIPES_GREGTECH { CI.getAlternativeTieredFluid(7, 144 * 18 * (GTNH ? 16 : 8)), }, - ItemUtils.getItemStack("miscutils:personalHealingDevice", 1), + ItemUtils.getItemStackFromFQRN("miscutils:personalHealingDevice", 1), 20 * 60 * 30 * (GTNH ? 2 : 1), (int) GT_Values.V[7]); @@ -335,7 +360,7 @@ public class RECIPES_GREGTECH { //Charge Pack LuV-UV ItemStack[] aChargeResearch = new ItemStack[] { - ItemUtils.getItemStack("miscutils:item.itemBufferCore7", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore7", 1), ItemUtils.getSimpleStack(ModItems.itemChargePack1, 1), ItemUtils.getSimpleStack(ModItems.itemChargePack2, 1), ItemUtils.getSimpleStack(ModItems.itemChargePack3, 1), @@ -349,10 +374,10 @@ public class RECIPES_GREGTECH { }; ItemStack[] aBufferCoreInputs = new ItemStack[] { - ItemUtils.getItemStack("miscutils:item.itemBufferCore7", GTNH ? 8 : 4), - ItemUtils.getItemStack("miscutils:item.itemBufferCore8", GTNH ? 8 : 4), - ItemUtils.getItemStack("miscutils:item.itemBufferCore9", GTNH ? 8 : 4), - ItemUtils.getItemStack("miscutils:item.itemBufferCore10", GTNH ? 8 : 4), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore7", GTNH ? 8 : 4), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore8", GTNH ? 8 : 4), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore9", GTNH ? 8 : 4), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore10", GTNH ? 8 : 4), }; int aCurrSlot = 0; @@ -696,21 +721,29 @@ public class RECIPES_GREGTECH { GT_Values.RA.addFluidCannerRecipe(ItemUtils.getSimpleStack(ModItems.itemSulfuricPotion), ItemUtils.getSimpleStack(Items.glass_bottle), null, FluidUtils.getFluidStack("sulfuricacid", 250)); - // Hydrofluoric Acid - GT_Values.RA.addFluidCannerRecipe(ItemUtils.getSimpleStack(Items.glass_bottle), - ItemUtils.getSimpleStack(ModItems.itemHydrofluoricPotion), - FluidUtils.getFluidStack("hydrofluoricacid", 250), null); - GT_Values.RA.addFluidCannerRecipe(ItemUtils.getSimpleStack(ModItems.itemHydrofluoricPotion), - ItemUtils.getSimpleStack(Items.glass_bottle), null, FluidUtils.getFluidStack("hydrofluoricacid", 250)); + + // Hydrofluoric Acid + boolean addedGtExtraction = false; + // Try use Internal GT Fluid first if (Utils.getGregtechVersionAsInt() >= 50929) { // Hydrofluoric Acid GT_Values.RA.addFluidCannerRecipe(ItemUtils.getSimpleStack(Items.glass_bottle), ItemUtils.getSimpleStack(ModItems.itemHydrofluoricPotion), FluidUtils.getFluidStack("hydrofluoricacid_gt5u", 250), null); - GT_Values.RA.addFluidCannerRecipe(ItemUtils.getSimpleStack(ModItems.itemHydrofluoricPotion), + addedGtExtraction = GT_Values.RA.addFluidCannerRecipe(ItemUtils.getSimpleStack(ModItems.itemHydrofluoricPotion), ItemUtils.getSimpleStack(Items.glass_bottle), null, FluidUtils.getFluidStack("hydrofluoricacid_gt5u", 250)); } + //Add a Fill recipe for GT++ Acid + GT_Values.RA.addFluidCannerRecipe(ItemUtils.getSimpleStack(Items.glass_bottle), + ItemUtils.getSimpleStack(ModItems.itemHydrofluoricPotion), + FluidUtils.getFluidStack("hydrofluoricacid", 125), null); + //Add an empty recipe, but only if we didn't for the standard GT HF. Prevents Fluid transformation exploits. + if (!addedGtExtraction) + GT_Values.RA.addFluidCannerRecipe(ItemUtils.getSimpleStack(ModItems.itemHydrofluoricPotion), + ItemUtils.getSimpleStack(Items.glass_bottle), null, FluidUtils.getFluidStack("hydrofluoricacid", 125)); + + } private static void cokeOvenRecipes() { @@ -1241,6 +1274,21 @@ public class RECIPES_GREGTECH { FluidUtils.getFluidStack("molten.krypton", 500), T6, 2000, 512000); + addAR(ItemUtils.getItemStackOfAmountFromOreDict( + "dustClay", 32), + GregtechItemList.Bomb_Cast_Mold.get(0), + FluidUtils.getWater(4000), + GregtechItemList.Bomb_Cast.get(4), + 30, 120); + addAR(ItemUtils.getSimpleStack(Items.redstone, 32), + ItemUtils.getSimpleStack(ModItems.itemRope, 16), + Materials.Glue.getFluid(500), + ItemUtils.getSimpleStack(ModItems.itemDetCable, 24), + 30, + 120); + + + /*addAR(ItemUtils.getItemStackOfAmountFromOreDict("plateIncoloy020", 16), ItemUtils.getItemStackOfAmountFromOreDict("frameGtIncoloyMA956", 4), null, GregtechItemList.Casing_Power_SubStation.get(4), 80, 120);*/ @@ -1457,6 +1505,52 @@ public class RECIPES_GREGTECH { ItemUtils.getItemStackOfAmountFromOreDict("dustSmallThorium", 20), ELEMENT.getInstance().URANIUM232.getDust(1), GT_Values.NI, GT_Values.NI, GT_Values.NI, new int[] { 0, 0, 10 }, 500 * 20, 2000); + + + //Process Used Fuel Rods for Krypton + + //Uranium + GT_Values.RA.addCentrifugeRecipe( + CI.getNumberedCircuit(20), + ItemUtils.getItemStackFromFQRN("IC2:reactorUraniumSimpledepleted", 8), + GT_Values.NF, + ELEMENT.getInstance().KRYPTON.getFluid(60), + ItemList.IC2_Fuel_Rod_Empty.get(8), + ELEMENT.getInstance().URANIUM238.getDust(2), + ELEMENT.getInstance().URANIUM232.getSmallDust(1), + ELEMENT.getInstance().URANIUM233.getSmallDust(1), + ELEMENT.getInstance().URANIUM235.getSmallDust(1), + ELEMENT.getInstance().PLUTONIUM239.getTinyDust(1), + new int[] { 0, 0, 1000, 1000, 1000, 500 }, 500 * 20, 4000); + //Mox + GT_Values.RA.addCentrifugeRecipe( + CI.getNumberedCircuit(20), + ItemUtils.getItemStackFromFQRN("IC2:reactorMOXSimpledepleted", 8), + GT_Values.NF, + ELEMENT.getInstance().KRYPTON.getFluid(90), + ItemList.IC2_Fuel_Rod_Empty.get(8), + ELEMENT.getInstance().PLUTONIUM244.getDust(2), + ELEMENT.getInstance().PLUTONIUM241.getTinyDust(1), + ELEMENT.getInstance().PLUTONIUM239.getTinyDust(1), + ELEMENT.getInstance().PLUTONIUM238.getTinyDust(1), + ELEMENT.getInstance().PLUTONIUM239.getTinyDust(1), + new int[] { 0, 0, 500, 500, 500, 500 }, 750 * 20, 4000); + + //Thorium + GT_Values.RA.addCentrifugeRecipe( + CI.getNumberedCircuit(20), + ItemList.Depleted_Thorium_1.get(8), + GT_Values.NF, + ELEMENT.getInstance().KRYPTON.getFluid(30), + ItemList.IC2_Fuel_Rod_Empty.get(8), + ELEMENT.getInstance().THORIUM.getDust(2), + ELEMENT.getInstance().THORIUM232.getDust(1), + ELEMENT.getInstance().LUTETIUM.getSmallDust(1), + ELEMENT.getInstance().POLONIUM.getSmallDust(1), + ELEMENT.getInstance().THALLIUM.getTinyDust(1), + new int[] { 0, 0, 5000, 5000, 5000, 2500 }, 250 * 20, 4000); + + } @@ -1510,6 +1604,24 @@ public class RECIPES_GREGTECH { ItemUtils.getItemStackOfAmountFromOreDict("dustLithium7", 16), FluidUtils.getFluidStack("water", 1000), FluidUtils.getFluidStack("lithiumhydroxide", 144 * 4), CI.emptyCells(1), 300 * 20); + + //Bombs + GT_Values.RA.addChemicalRecipe( + ItemUtils.getSimpleStack(ModItems.itemBombCasing, 4), + ItemUtils.getSimpleStack(RocketFuels.Ammonium_Nitrate_Dust, 8), + Materials.Fuel.getFluid(1000), + null, + ItemUtils.getSimpleStack(ModItems.itemBombUnf, 4), + 300 * 20); + + GT_Values.RA.addChemicalRecipe( + ItemUtils.getSimpleStack(ModItems.itemBombUnf, 4), + ItemUtils.getSimpleStack(ModItems.itemDetCable, 4), + FluidUtils.getFluidStack(RocketFuels.Kerosene, 100), + null, + ItemUtils.getSimpleStack(ModItems.itemBomb, 4), + 10 * 20); + // LFTR Fuel Related Compounds if (GTNH) { @@ -1612,6 +1724,18 @@ public class RECIPES_GREGTECH { MaterialUtils.getVoltageForTier(GTNH ? 5 : 4), 4500); + //Bomb Casings + GT_Values.RA.addBlastRecipe( + GregtechItemList.Bomb_Cast.get(4), + ALLOY.STEEL.getDust(16), + ELEMENT.getInstance().OXYGEN.getFluid(2000), + GT_Values.NF, + GregtechItemList.Bomb_Cast_Molten.get(4), + null, + 4 * 60 * 20, + MaterialUtils.getVoltageForTier(GTNH ? 3 : 2), + 2800); + } @@ -1646,10 +1770,9 @@ public class RECIPES_GREGTECH { GT_ModHandler.addPulverisationRecipe(ItemUtils.getItemStackOfAmountFromOreDict("blockMeatRaw", 1), ItemUtils.getItemStackOfAmountFromOreDict("dustMeatRaw", 9)); - /* - * GT_ModHandler.addPulverisationRecipe( FLUORIDES.FLUORITE.getOre(1), - * FLUORIDES.FLUORITE.getDust(4)); - */ + + GT_ModHandler.addPulverisationRecipe(GregtechItemList.Bomb_Cast_Broken.get(1), + ItemUtils.getItemStackOfAmountFromOreDict("dustClay", 3)); if (ItemUtils.simpleMetaStack("chisel:limestone", 0, 1) != null) { GT_ModHandler.addPulverisationRecipe(ItemUtils.getItemStackOfAmountFromOreDict("limestone", 1), diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPES_General.java b/src/Java/gtPlusPlus/core/recipe/RECIPES_General.java index 54380306cc..6ed5c71bcc 100644 --- a/src/Java/gtPlusPlus/core/recipe/RECIPES_General.java +++ b/src/Java/gtPlusPlus/core/recipe/RECIPES_General.java @@ -50,7 +50,7 @@ public class RECIPES_General { RECIPE_Obsidian = ItemUtils.getSimpleStack(Blocks.obsidian); RECIPE_CraftingTable = ItemUtils.getSimpleStack(Blocks.crafting_table); RECIPE_HydrogenDust = ItemUtils.getSimpleStack(ModItems.itemHydrogenBlob); - RECIPE_BasicCasingIC2 = ItemUtils.getItemStack("IC2:blockMachine", 1); + RECIPE_BasicCasingIC2 = ItemUtils.getItemStackFromFQRN("IC2:blockMachine", 1); OUTPUT_Workbench_Bronze = ItemUtils.getSimpleStack(ModBlocks.blockWorkbench); OUTPUT_Blueprint = ItemUtils.getSimpleStack(ModItems.itemBlueprintBase); run(); @@ -127,9 +127,9 @@ public class RECIPES_General { //Iron bars final ItemStack ironBars; if (CORE.GTNH) { - ironBars = ItemUtils.getItemStack("dreamcraft:item.SteelBars", 1); + ironBars = ItemUtils.getItemStackFromFQRN("dreamcraft:item.SteelBars", 1); } else { - ironBars = ItemUtils.getItemStack("minecraft:iron_bars", 1); + ironBars = ItemUtils.getItemStackFromFQRN("minecraft:iron_bars", 1); } //Fish Trap @@ -154,7 +154,7 @@ public class RECIPES_General { null, CI.craftingToolWrench, null, ironRecipe, ironRecipe, ironRecipe, ironRecipe, ironRecipe, ironRecipe, - ItemUtils.getItemStack("minecraft:iron_bars", 8))) { + ItemUtils.getItemStackFromFQRN("minecraft:iron_bars", 8))) { Logger.INFO("Re-added old GT recipe for Iron Bars."); } } @@ -235,14 +235,14 @@ public class RECIPES_General { Logger.INFO("Added a recipe for Wither Cages."); } - Logger.RECIPE("[Inspection] Xp Converter"); + /*Logger.RECIPE("[Inspection] Xp Converter"); if (RecipeUtils.recipeBuilder( getSimpleStack(Items.experience_bottle), ItemUtils.simpleMetaStack(ModBlocks.blockCompressedObsidian, 2, 1), getSimpleStack(Items.experience_bottle), ItemUtils.simpleMetaStack(ModBlocks.blockCompressedObsidian, 5, 1), getSimpleStack(Items.nether_star), ItemUtils.simpleMetaStack(ModBlocks.blockCompressedObsidian, 5, 1), getSimpleStack(Items.experience_bottle), ItemUtils.simpleMetaStack(ModBlocks.blockCompressedObsidian, 2, 1), getSimpleStack(Items.experience_bottle), ItemUtils.getSimpleStack(ModBlocks.blockXpConverter, 1))){ Logger.INFO("Added a recipe for XP Converter."); - } + }*/ @@ -287,7 +287,7 @@ public class RECIPES_General { ItemUtils.getSimpleStack(ModBlocks.blockNet, 8), ItemUtils.getSimpleStack(Blocks.vine, 8), ALLOY.TUMBAGA.getRing(1), }, FluidUtils.getWater(1000), // Fluid - ItemUtils.getItemStack("miscutils:SlowBuildingRing", 1), // Output + ItemUtils.getItemStackFromFQRN("miscutils:SlowBuildingRing", 1), // Output 20 * 30, // Dur 16); // Eu diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPES_Machines.java b/src/Java/gtPlusPlus/core/recipe/RECIPES_Machines.java index a7c0655f89..54d9994edc 100644 --- a/src/Java/gtPlusPlus/core/recipe/RECIPES_Machines.java +++ b/src/Java/gtPlusPlus/core/recipe/RECIPES_Machines.java @@ -97,16 +97,16 @@ public class RECIPES_Machines { //Buffer Cores - public static ItemStack RECIPE_BufferCore_ULV = ItemUtils.getItemStack("miscutils:item.itemBufferCore1", 1); - public static ItemStack RECIPE_BufferCore_LV = ItemUtils.getItemStack("miscutils:item.itemBufferCore2", 1); - public static ItemStack RECIPE_BufferCore_MV = ItemUtils.getItemStack("miscutils:item.itemBufferCore3", 1); - public static ItemStack RECIPE_BufferCore_HV = ItemUtils.getItemStack("miscutils:item.itemBufferCore4", 1); - public static ItemStack RECIPE_BufferCore_EV = ItemUtils.getItemStack("miscutils:item.itemBufferCore5", 1); - public static ItemStack RECIPE_BufferCore_IV = ItemUtils.getItemStack("miscutils:item.itemBufferCore6", 1); - public static ItemStack RECIPE_BufferCore_LuV = ItemUtils.getItemStack("miscutils:item.itemBufferCore7", 1); - public static ItemStack RECIPE_BufferCore_ZPM = ItemUtils.getItemStack("miscutils:item.itemBufferCore8", 1); - public static ItemStack RECIPE_BufferCore_UV = ItemUtils.getItemStack("miscutils:item.itemBufferCore9", 1); - public static ItemStack RECIPE_BufferCore_MAX = ItemUtils.getItemStack("miscutils:item.itemBufferCore10", 1); + public static ItemStack RECIPE_BufferCore_ULV = ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore1", 1); + public static ItemStack RECIPE_BufferCore_LV = ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore2", 1); + public static ItemStack RECIPE_BufferCore_MV = ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore3", 1); + public static ItemStack RECIPE_BufferCore_HV = ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore4", 1); + public static ItemStack RECIPE_BufferCore_EV = ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore5", 1); + public static ItemStack RECIPE_BufferCore_IV = ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore6", 1); + public static ItemStack RECIPE_BufferCore_LuV = ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore7", 1); + public static ItemStack RECIPE_BufferCore_ZPM = ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore8", 1); + public static ItemStack RECIPE_BufferCore_UV = ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore9", 1); + public static ItemStack RECIPE_BufferCore_MAX = ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore10", 1); //Wire @@ -181,7 +181,7 @@ public class RECIPES_Machines { //Lava Boiler public static ItemStack boiler_Coal; - public static ItemStack blockBricks = ItemUtils.getItemStack("minecraft:brick_block", 1); + public static ItemStack blockBricks = ItemUtils.getItemStackFromFQRN("minecraft:brick_block", 1); //Batteries public static String batteryBasic = "batteryBasic"; @@ -354,6 +354,36 @@ public class RECIPES_Machines { ItemUtils.getSimpleStack(ModBlocks.blockCustomJukebox), 20 * 30, 30); + + //Poo Collector + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { + CI.machineHull_MV, + CI.getTieredComponent(OrePrefixes.circuit, 2, GTNH ? 4 : 2), + CI.getTieredComponent(OrePrefixes.pipeMedium, 2, GTNH ? 4 : 2), + CI.getElectricPump(2, GTNH ? 4 : 2), + ALLOY.EGLIN_STEEL.getPlate(GTNH ? 8 : 4), + ALLOY.POTIN.getScrew(GTNH ? 12 : 6) + }, + ALLOY.TUMBAGA.getFluid(144 * 4), + ItemUtils.getSimpleStack(ModBlocks.blockPooCollector), + 20 * 60, + 30); + + //Adv. Poo Collector + CORE.RA.addSixSlotAssemblingRecipe( + new ItemStack[] { + CI.getTieredMachineHull(-1), + ItemUtils.getSimpleStack(ModBlocks.blockPooCollector), + CI.getTieredComponent(OrePrefixes.circuit, 5, GTNH ? 8 : 4), + CI.getTieredComponent(OrePrefixes.pipeHuge, 6, GTNH ? 8 : 4), + CI.getElectricPump(5, GTNH ? 12 : 6), + CI.getTieredComponent(OrePrefixes.screw, 6, GTNH ? 32 : 16) + }, + CI.getAlternativeTieredFluid(5, 144 * 9), + ItemUtils.getSimpleStack(ModBlocks.blockPooCollector, 8, 1), + 20 * 60 * 5, + 500); //Basic Steam Turbine @@ -990,7 +1020,7 @@ public class RECIPES_Machines { "plateDoubleZeron100", CI.craftingToolHammer_Hard, "plateDoubleZeron100", RECIPE_LFTRInnerCasing); - ItemStack IC2HeatPlate = ItemUtils.getItemStack("IC2:reactorPlatingHeat", 1); + ItemStack IC2HeatPlate = ItemUtils.getItemStackFromFQRN("IC2:reactorPlatingHeat", 1); RecipeUtils.addShapedGregtechRecipe( "plateDoubleHastelloyN", IC2HeatPlate, "plateDoubleHastelloyN", IC2HeatPlate, "frameGtHastelloyC276", IC2HeatPlate, @@ -1605,7 +1635,7 @@ public class RECIPES_Machines { Item aBaseCore = ModItems.itemControlCore; ItemStack[] aInputPrevTier = new ItemStack[] { - GTNH ? ItemUtils.getItemStack("miscutils:item.itemBufferCore3", 1) : ItemUtils.getItemStack("miscutils:item.itemBufferCore2", 1), + GTNH ? ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore3", 1) : ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore2", 1), ItemUtils.simpleMetaStack(aBaseCore, 0, 1), ItemUtils.simpleMetaStack(aBaseCore, 1, 1), ItemUtils.simpleMetaStack(aBaseCore, 2, 1), @@ -1636,7 +1666,7 @@ public class RECIPES_Machines { aOutput[1], aMat_A[1].getGear(GTNH ? 4 : 2), aMat_B[2].getPlateDouble(GTNH ? 16 : 8), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+(GTNH ? "2" : "1"), GTNH ? 4 : 2), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+(GTNH ? "2" : "1"), GTNH ? 4 : 2), ItemUtils.getItemStackOfAmountFromOreDict(CI.getTieredCircuitOreDictName(GTNH ? 3 : 2), GTNH ? 10 : 5) }, aMat_B[3].getFluid(144 * 8), //Input Fluid @@ -1646,11 +1676,10 @@ public class RECIPES_Machines { for (int i = 0; i < 10; i++) { - boolean aDub = i >= 5; - + boolean aDub = false; ItemStack aPlateStack = aMat_A[i].getPlateDouble((GTNH ? 16 : 8) * (aDub ? 2 : 1)); - ItemStack aGearStack = aMat_B[i].getGear(GTNH ? 8 : 4 * (aDub ? 2 : 1)); - ItemStack aRodStack = aMat_A[i].getLongRod(GTNH ? 32 : 16 * (aDub ? 2 : 1)); + ItemStack aGearStack = aMat_B[i].getGear(GTNH ? 4 : 2 * (aDub ? 2 : 1)); + ItemStack aRodStack = aMat_A[i].getLongRod(GTNH ? 16 : 8 * (aDub ? 2 : 1)); ItemStack aScrewStack = aMat_B[i].getScrew(32 * (aDub ? 2 : 1)); if (!ItemUtils.checkForInvalidItems(aPlateStack)) { @@ -1674,14 +1703,14 @@ public class RECIPES_Machines { CORE.RA.addSixSlotAssemblingRecipe( new ItemStack[] { - aInputPrevTier[i], + CI.getEnergyCore(i, 4), aPlateStack, aGearStack, aRodStack, aScrewStack, - ItemUtils.getItemStackOfAmountFromOreDict(CI.getTieredCircuitOreDictName((int) (4+Math.ceil((double) i / (double) 2))), GTNH ? (i * 2 * 2 * 2) : (i * 2 * 2)) + ItemUtils.getItemStackOfAmountFromOreDict(CI.getTieredCircuitOreDictName((int) (4+Math.ceil((double) i / (double) 2))), GTNH ? (i * 2 * 2) : (i * 2)) }, - aMat_A[i].getFluid(144 * 4 * (i+1)), //Input Fluid + CI.getTieredFluid(i, 144 * 4 * (i+1)), //Input Fluid aOutput[i], 60 * 20 * 1 * (i+1), MaterialUtils.getVoltageForTier(i)); @@ -1806,16 +1835,16 @@ public class RECIPES_Machines { ItemStack[] aOutput = new ItemStack[] { - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"1", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"2", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"3", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"4", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"5", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"6", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"7", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"8", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"9", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"10", 1) + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"1", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"2", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"3", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"4", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"5", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"6", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"7", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"8", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"9", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"10", 1) }; int aCostMultiplier = GTNH ? 4 : 1; diff --git a/src/Java/gtPlusPlus/core/recipe/common/CI.java b/src/Java/gtPlusPlus/core/recipe/common/CI.java index 28fa12ac1a..ba592bcb65 100644 --- a/src/Java/gtPlusPlus/core/recipe/common/CI.java +++ b/src/Java/gtPlusPlus/core/recipe/common/CI.java @@ -436,8 +436,11 @@ public class CI { else if (tier == 8){ return machineHull_UV; } + else if (tier == 9){ + return machineHull_MAX; + } else { - return machineHull_MAX; + return GregtechItemList.Casing_Multi_Use.get(1); } } @@ -469,8 +472,11 @@ public class CI { else if (tier == 8){ return machineCasing_UV; } + else if (tier == 9){ + return machineCasing_MAX; + } else { - return machineCasing_MAX; + return GregtechItemList.Casing_Multi_Use.get(1); } } @@ -631,16 +637,16 @@ public class CI { public static ItemStack getEnergyCore(int aTier, int aAmount) { ItemStack[] aOutput = new ItemStack[] { - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"1", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"2", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"3", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"4", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"5", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"6", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"7", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"8", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"9", 1), - ItemUtils.getItemStack("miscutils:item.itemBufferCore"+"10", 1) + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"1", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"2", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"3", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"4", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"5", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"6", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"7", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"8", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"9", 1), + ItemUtils.getItemStackFromFQRN("miscutils:item.itemBufferCore"+"10", 1) }; return ItemUtils.getSimpleStack(aOutput[MathUtils.balance(aTier, 0, 9)], aAmount); } @@ -718,6 +724,11 @@ public class CI { } if (aPrefix == OrePrefixes.pipeTiny || aPrefix == OrePrefixes.pipeSmall || aPrefix == OrePrefixes.pipe || aPrefix == OrePrefixes.pipeMedium || aPrefix == OrePrefixes.pipeLarge || aPrefix == OrePrefixes.pipeHuge) { + + if (aPrefix == OrePrefixes.pipe) { + aPrefix = OrePrefixes.pipeMedium; + } + if (aTier == 0) { return ItemUtils.getOrePrefixStack(aPrefix, Materials.Lead, aAmount); } diff --git a/src/Java/gtPlusPlus/core/tileentities/ModTileEntities.java b/src/Java/gtPlusPlus/core/tileentities/ModTileEntities.java index da018675f3..bb7004350d 100644 --- a/src/Java/gtPlusPlus/core/tileentities/ModTileEntities.java +++ b/src/Java/gtPlusPlus/core/tileentities/ModTileEntities.java @@ -14,7 +14,8 @@ public class ModTileEntities { public static void init() { Logger.INFO("Registering Tile Entities."); - GameRegistry.registerTileEntity(TileEntityHeliumGenerator.class, "HeliumGenerator"); + GameRegistry.registerTileEntity(TileEntityPooCollector.class, "TileEntityPooCollector"); + GameRegistry.registerTileEntity(TileEntityAdvPooCollector.class, "TileEntityAdvPooCollector"); GameRegistry.registerTileEntity(TileEntityWorkbench.class, "TileWorkbench"); GameRegistry.registerTileEntity(TileEntityWorkbenchAdvanced.class, "TileWorkbenchAdvanced"); GameRegistry.registerTileEntity(TileEntityFishTrap.class, "TileFishTrap"); diff --git a/src/Java/gtPlusPlus/core/tileentities/base/TileEntityBase.java b/src/Java/gtPlusPlus/core/tileentities/base/TileEntityBase.java index 0a1c53d79d..4f9a8d3748 100644 --- a/src/Java/gtPlusPlus/core/tileentities/base/TileEntityBase.java +++ b/src/Java/gtPlusPlus/core/tileentities/base/TileEntityBase.java @@ -28,6 +28,7 @@ import net.minecraftforge.fluids.IFluidHandler; import gtPlusPlus.api.interfaces.ILazyCoverable; import gtPlusPlus.api.objects.Logger; import gtPlusPlus.api.objects.minecraft.BTF_Inventory; +import gtPlusPlus.core.util.data.ArrayUtils; import gtPlusPlus.core.util.minecraft.gregtech.PollutionUtils; import ic2.api.Direction; @@ -81,6 +82,9 @@ public class TileEntityBase extends TileEntity implements ILazyCoverable, IGregT public void updateEntity() { long aTick = System.currentTimeMillis(); this.isDead = false; + if (!firstTicked) { + onFirstTick(); + } try{ if (this.isServerSide()){ onPreTick(aTick); @@ -1297,7 +1301,22 @@ public class TileEntityBase extends TileEntity implements ILazyCoverable, IGregT public boolean energyStateReady() { return false; } - + + + private boolean firstTicked = false; + + public boolean onFirstTick() { + if (!firstTicked) { + firstTicked = true; + if (this.mInventory != null) { + this.mInventory.purgeNulls(); + return true; + } + } + return false; + } + + diff --git a/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityAdvPooCollector.java b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityAdvPooCollector.java new file mode 100644 index 0000000000..18954f12b6 --- /dev/null +++ b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityAdvPooCollector.java @@ -0,0 +1,157 @@ +package gtPlusPlus.core.tileentities.machines; + +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.item.chemistry.AgriculturalChem; +import gtPlusPlus.core.util.math.MathUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.passive.EntityAnimal; +import net.minecraft.entity.passive.EntityChicken; +import net.minecraft.entity.passive.EntityCow; +import net.minecraft.entity.passive.EntityHorse; +import net.minecraft.entity.passive.EntityMooshroom; +import net.minecraft.entity.passive.EntitySheep; +import net.minecraft.entity.passive.EntityVillager; +import net.minecraft.entity.passive.IAnimals; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; + +public class TileEntityAdvPooCollector extends TileEntityBaseFluidCollector { + + public TileEntityAdvPooCollector() { + super(18, 128000); + } + + + @Override + public boolean canFill(ForgeDirection from, Fluid fluid) { + return false; + } + + @Override + public boolean canDrain(ForgeDirection from, Fluid fluid) { + return true; + } + + public void onPreLogicTick() { + + } + + public <V> boolean addDrop(V aPooMaker) { + int aChance = MathUtils.randInt(0, 50000); + if (aChance > 0) { + ItemStack aPoop; + if (aChance<= 200) { + aPoop = ItemUtils.getItemStackOfAmountFromOreDict("dustManureByproducts", 1); + } + else if (aChance <= 1000) { + aPoop = ItemUtils.getItemStackOfAmountFromOreDict("dustSmallManureByproducts", 1); + } + else if (aChance <= 2000) { + aPoop = ItemUtils.getItemStackOfAmountFromOreDict("dustTinyManureByproducts", 1); + } + else { + return false; + } + + //Add to inventory if not full, else espawn in world + if (!this.mInventory.addItemStack(aPoop)) { + EntityItem entity = new EntityItem(worldObj, xCoord, yCoord+1.5, zCoord, aPoop); + worldObj.spawnEntityInWorld(entity); + } + + } + + + return false; + } + + private static AutoMap<Class> aEntityToDrain = new AutoMap<Class>(); + + @Override + public AutoMap<Class> aThingsToLookFor() { + if (aEntityToDrain.isEmpty()) { + aEntityToDrain.add(EntityAnimal.class); + aEntityToDrain.add(IAnimals.class); + aEntityToDrain.add(EntityVillager.class); + aEntityToDrain.add(EntityPlayer.class); + } + return aEntityToDrain; + } + + @Override + public <V> int onPostTick(V aPooMaker) { + if (this.tank.getFluidAmount() < this.tank.getCapacity()) { + int aPooAmount = 0; + // Vanilla Animals + if (aPooMaker instanceof EntityChicken) { + aPooAmount = MathUtils.randInt(1, 40); + } + else if (aPooMaker instanceof EntityHorse) { + aPooAmount = MathUtils.randInt(20, 40); + } + else if (aPooMaker instanceof EntityCow) { + aPooAmount = MathUtils.randInt(18, 45); + } + else if (aPooMaker instanceof EntityMooshroom) { + aPooAmount = 17; + } + else if (aPooMaker instanceof EntitySheep) { + aPooAmount = MathUtils.randInt(8, 30); + } + + else { + if (aPooMaker instanceof EntityAnimal || aPooMaker instanceof IAnimals) { + aPooAmount = MathUtils.randInt(5, 35); + } + else if (aPooMaker instanceof EntityVillager) { + aPooAmount = MathUtils.randInt(25, 30); + } + else if (aPooMaker instanceof EntityPlayer) { + aPooAmount = MathUtils.randInt(1, 3); + } + else { + aPooAmount = MathUtils.randInt(1, 10); + } + } + aPooAmount = Math.max(Math.min(this.tank.getCapacity()-this.tank.getFluidAmount(), aPooAmount), 1); + return Math.max(1, (aPooAmount * MathUtils.getRandomFromArray(new int[] {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 4}) / 10)); + } + else { + return 0; + } + } + + @Override + public Fluid fluidToProvide() { + return AgriculturalChem.PoopJuice; + } + + @Override + public Item itemToSpawnInWorldIfTankIsFull() { + int a = MathUtils.randInt(0, 75); + Item aItem = null; + if (a <= 30) { + aItem = AgriculturalChem.dustDirt; + } + else if (a <= 40) { + aItem = ItemUtils.getItemStackOfAmountFromOreDict("dustManureByproducts", 1).getItem(); + } + else if (a <= 55) { + aItem = ItemUtils.getItemStackOfAmountFromOreDict("dustSmallManureByproducts", 1).getItem(); + } + return aItem; + } + + public int getBaseTickRate() { + return MathUtils.randInt(50, 200); + } + + + + +} diff --git a/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityBaseFluidCollector.java b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityBaseFluidCollector.java new file mode 100644 index 0000000000..78b8f74799 --- /dev/null +++ b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityBaseFluidCollector.java @@ -0,0 +1,238 @@ +package gtPlusPlus.core.tileentities.machines; + +import java.util.List; + +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.api.objects.minecraft.BTF_FluidTank; +import gtPlusPlus.api.objects.minecraft.BlockPos; +import gtPlusPlus.core.tileentities.base.TileEntityBase; +import gtPlusPlus.core.util.math.MathUtils; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.world.World; +import net.minecraft.world.chunk.Chunk; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidEvent; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTank; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; + +public abstract class TileEntityBaseFluidCollector extends TileEntityBase implements IFluidHandler { + + public final FluidTank tank; + private boolean needsUpdate = false; + private int updateTimer = 0; + private long internalTickCounter = 0; + private BlockPos internalBlockLocation; + + public TileEntityBaseFluidCollector(int aInvSlotCount, int aTankCapcity) { + super(aInvSlotCount); + tank = new BTF_FluidTank(aTankCapcity); + } + + @Override + public final int fill(ForgeDirection from, FluidStack resource, boolean doFill) { + needsUpdate = true; + return this.tank.fill(resource, doFill); + } + + @Override + public final FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) { + needsUpdate = true; + return this.tank.drain(resource.amount, doDrain); + } + + @Override + public final FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) { + needsUpdate = true; + FluidStack fluid = this.tank.getFluid(); + // return this.tank.drain(maxDrain, doDrain); + if (fluid == null) { + return null; + } + + int drained = maxDrain; + if (fluid.amount < drained) { + drained = fluid.amount; + } + + FluidStack stack = new FluidStack(fluid, drained); + if (doDrain) { + fluid.amount -= drained; + if (fluid.amount <= 0) { + fluid = null; + } + + if (this != null) { + FluidEvent.fireEvent(new FluidEvent.FluidDrainingEvent(fluid, this.getWorldObj(), this.xCoord, + this.yCoord, this.zCoord, this.tank, 0)); + } + } + return stack; + } + + @Override + public boolean canFill(ForgeDirection from, Fluid fluid) { + return false; + } + + @Override + public boolean canDrain(ForgeDirection from, Fluid fluid) { + return true; + } + + @Override + public final FluidTankInfo[] getTankInfo(ForgeDirection from) { + return new FluidTankInfo[] { this.tank.getInfo() }; + } + + @Override + public final void updateEntity() { + super.updateEntity(); + onPreLogicTick(); + logicTick(); + if (needsUpdate) { + if (updateTimer == 0) { + updateTimer = 10; // every 10 ticks it will send an update + } else { + --updateTimer; + if (updateTimer == 0) { + worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); + needsUpdate = false; + } + } + } + } + + @Override + public void readFromNBT(NBTTagCompound tag) { + tank.readFromNBT(tag); + super.readFromNBT(tag); + } + + @Override + public void writeToNBT(NBTTagCompound tag) { + tank.writeToNBT(tag); + super.writeToNBT(tag); + } + + @Override + public final Packet getDescriptionPacket() { + NBTTagCompound tag = new NBTTagCompound(); + writeToNBT(tag); + return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, this.blockMetadata, tag); + } + + @Override + public final void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) { + NBTTagCompound tag = pkt.func_148857_g(); + readFromNBT(tag); + } + + public int getBaseTickRate() { + return MathUtils.randInt(200, 300); + } + + public abstract AutoMap<Class> aThingsToLookFor(); + + public abstract void onPreLogicTick(); + + public final void logicTick() { + + if (this.worldObj == null || this.worldObj.isRemote) { + return; + } + if (internalTickCounter % getBaseTickRate() == 0) { + if (internalBlockLocation == null) { + internalBlockLocation = new BlockPos(this); + } + BlockPos p = internalBlockLocation; + if (p != null) { + if (p.world != null) { + World w = this.worldObj; + if (w == null) { + return; + } + Chunk c = w.getChunkFromBlockCoords(p.xPos, p.zPos); + if (c != null) { + if (c.isChunkLoaded) { + int startX = p.xPos - 2; + int startY = p.yPos; + int startZ = p.zPos - 2; + int endX = p.xPos + 3; + int endY = p.yPos + 5; + int endZ = p.zPos + 3; + AxisAlignedBB box = AxisAlignedBB.getBoundingBox(startX, startY, startZ, endX, endY, endZ); + if (box != null) { + for (Class c2 : aThingsToLookFor()) { + tickEntityType(w, box, c2); + } + } else { + return; + } + } + } + } + } + + } + + internalTickCounter++; + } + + @SuppressWarnings("unchecked") + public final void tickEntityType(World w, AxisAlignedBB box, Class aClassToFind) { + List<?> entities = w.getEntitiesWithinAABB(aClassToFind, box); + if (entities != null && !entities.isEmpty()) { + interactWithEntities(entities); + } + } + + public final <V> void interactWithEntities(List<V> entities) { + for (V aEntity : entities) { + addDrop(aEntity); + if (this.tank.getFluidAmount() < this.tank.getCapacity()) { + int aFluidAmount = onPostTick(aEntity); + aFluidAmount = Math.max(Math.min(this.tank.getCapacity()-this.tank.getFluidAmount(), aFluidAmount), 1); + this.tank.fill(FluidUtils.getFluidStack(fluidToProvide(), aFluidAmount), true); + } + else { + ItemStack aDirtStack = ItemUtils.getSimpleStack(itemToSpawnInWorldIfTankIsFull()); + if (aDirtStack != null) + if (!this.mInventory.addItemStack(aDirtStack)) { + EntityItem entity = new EntityItem(worldObj, xCoord, yCoord+1.5, zCoord, aDirtStack); + worldObj.spawnEntityInWorld(entity); + } + } + } + } + + + /** + * Return the amount of fluid for this entity type + * @param aEntity + * @return + */ + public abstract <V> int onPostTick(V aEntity); + + public abstract <V> boolean addDrop(V aPooMaker); + + public abstract Fluid fluidToProvide(); + + public abstract Item itemToSpawnInWorldIfTankIsFull(); + + + + +} diff --git a/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityPooCollector.java b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityPooCollector.java new file mode 100644 index 0000000000..f6570c6cc6 --- /dev/null +++ b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityPooCollector.java @@ -0,0 +1,144 @@ +package gtPlusPlus.core.tileentities.machines; + +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.item.chemistry.AgriculturalChem; +import gtPlusPlus.core.util.math.MathUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.passive.EntityAnimal; +import net.minecraft.entity.passive.EntityChicken; +import net.minecraft.entity.passive.EntityCow; +import net.minecraft.entity.passive.EntityHorse; +import net.minecraft.entity.passive.EntityMooshroom; +import net.minecraft.entity.passive.EntitySheep; +import net.minecraft.entity.passive.IAnimals; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; + +public class TileEntityPooCollector extends TileEntityBaseFluidCollector { + + public TileEntityPooCollector() { + super(9, 8000); + } + + + @Override + public boolean canFill(ForgeDirection from, Fluid fluid) { + return false; + } + + @Override + public boolean canDrain(ForgeDirection from, Fluid fluid) { + return true; + } + + public void onPreLogicTick() { + + } + + public <V> boolean addDrop(V aPooMaker) { + int aChance = MathUtils.randInt(0, 50000); + if (aChance > 0) { + ItemStack aPoop; + if (aChance<= 100) { + aPoop = ItemUtils.getItemStackOfAmountFromOreDict("dustManureByproducts", 1); + } + else if (aChance <= 500) { + aPoop = ItemUtils.getItemStackOfAmountFromOreDict("dustSmallManureByproducts", 1); + } + else if (aChance <= 1250) { + aPoop = ItemUtils.getItemStackOfAmountFromOreDict("dustTinyManureByproducts", 1); + } + else { + return false; + } + //Add poop to world + //Logger.INFO("Adding animal waste for "+aPooMaker.getCommandSenderName()); + + //Add to inventory if not full, else espawn in world + if (!this.mInventory.addItemStack(aPoop)) { + EntityItem entity = new EntityItem(worldObj, xCoord, yCoord+1.5, zCoord, aPoop); + worldObj.spawnEntityInWorld(entity); + } + + } + + + return false; + } + + private static AutoMap<Class> aEntityToDrain = new AutoMap<Class>(); + + @Override + public AutoMap<Class> aThingsToLookFor() { + if (aEntityToDrain.isEmpty()) { + aEntityToDrain.add(EntityAnimal.class); + aEntityToDrain.add(IAnimals.class); + } + return aEntityToDrain; + } + + @Override + public <V> int onPostTick(V aPooMaker) { + if (this.tank.getFluidAmount() < this.tank.getCapacity()) { + int aPooAmount = 0; + // Vanilla Animals + if (aPooMaker instanceof EntityChicken) { + aPooAmount = MathUtils.randInt(1, 40); + } + else if (aPooMaker instanceof EntityHorse) { + aPooAmount = MathUtils.randInt(20, 40); + } + else if (aPooMaker instanceof EntityCow) { + aPooAmount = MathUtils.randInt(18, 45); + } + else if (aPooMaker instanceof EntityMooshroom) { + aPooAmount = 17; + } + else if (aPooMaker instanceof EntitySheep) { + aPooAmount = MathUtils.randInt(8, 30); + } + + else { + if (aPooMaker instanceof EntityAnimal || aPooMaker instanceof IAnimals) { + aPooAmount = MathUtils.randInt(5, 35); + } + else { + aPooAmount = MathUtils.randInt(1, 10); + } + } + aPooAmount = Math.max((Math.min(this.tank.getCapacity()-this.tank.getFluidAmount(), aPooAmount)/10), 1); + return aPooAmount; + } + else { + return 0; + } + } + + @Override + public Fluid fluidToProvide() { + return AgriculturalChem.PoopJuice; + } + + @Override + public Item itemToSpawnInWorldIfTankIsFull() { + int a = MathUtils.randInt(0, 100); + Item aItem = null; + if (a <= 30) { + aItem = AgriculturalChem.dustDirt; + } + else if (a <= 40) { + aItem = ItemUtils.getItemStackOfAmountFromOreDict("dustSmallManureByproducts", 1).getItem(); + } + else if (a <= 55) { + aItem = ItemUtils.getItemStackOfAmountFromOreDict("dustTinyManureByproducts", 1).getItem(); + } + return aItem; + } + + + + +} diff --git a/src/Java/gtPlusPlus/core/util/Utils.java b/src/Java/gtPlusPlus/core/util/Utils.java index 7d1d42abf0..d032384638 100644 --- a/src/Java/gtPlusPlus/core/util/Utils.java +++ b/src/Java/gtPlusPlus/core/util/Utils.java @@ -948,4 +948,16 @@ public class Utils { return aOther; } + public static long getMillisSince(long aStartTime, long aCurrentTime) { + return (aCurrentTime - aStartTime); + } + + public static long getSecondsFromMillis(long aMillis) { + return (aMillis/1000); + } + + public static long getTicksFromSeconds(long aSeconds) { + return (aSeconds*20); + } + } diff --git a/src/Java/gtPlusPlus/core/util/data/StringUtils.java b/src/Java/gtPlusPlus/core/util/data/StringUtils.java index b64266b5d4..2372d04c15 100644 --- a/src/Java/gtPlusPlus/core/util/data/StringUtils.java +++ b/src/Java/gtPlusPlus/core/util/data/StringUtils.java @@ -1,5 +1,9 @@ package gtPlusPlus.core.util.data; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.util.Utils; + public class StringUtils { public static String superscript(String str) { @@ -131,4 +135,85 @@ public class StringUtils { return aData; } } + + + + /** + * Is this a special regex character for delimination? (.$|()[]{}^?*+\\) + * @param aChar - The char to test + * @return - Is this a special character? + */ + public static boolean isSpecialCharacter(char aChar) { + if (aChar == '"' || aChar == '.' || aChar == '$' || aChar == '|' || aChar == '(' || aChar == ')' || aChar == '[' + || aChar == ']' || aChar == '{' || aChar == '}' || aChar == '^' || aChar == '?' || aChar == '*' + || aChar == '+' || aChar == '\\') { + return true; + } + return false; + } + + public static boolean isEscaped(String aString) { + return aString.substring(0, 1).equals("\\"); + } + + public static String splitAndUppercase(String aInput, String aDelim) { + + if (!isEscaped(aDelim)) { + boolean isSpecial = false; + for (int o=0;o<aInput.length();o++) { + if (isSpecialCharacter(aInput.charAt(o))) { + isSpecial = true; + } + } + if (isSpecial) { + aDelim = "\\"+aDelim; + } + } + + + Logger.INFO("Splitting "+aInput); + String[] aSplit = aInput.split(aDelim); + Logger.INFO("Split into "+aSplit == null ? ""+0 : aSplit.length+" parts."); + if (aSplit == null || aSplit.length == 0) { + return aInput; + } + else { + AutoMap<String> aTemp = new AutoMap<String>(); + for (String s : aSplit) { + Logger.INFO("Found: "+s); + s = s.replace(".", ""); + s = Utils.sanitizeString(s); + s = firstLetterCaps(s); + Logger.INFO("Formatted & Captilized: "+s); + aTemp.put(s); + } + Logger.INFO("Rebuilding"); + String aReturn = ""; + for (String s : aTemp) { + aReturn += s; + Logger.INFO("Step: "+aReturn); + } + return aReturn; + } + } + + public static int characterCount(String aString, char aChar) { + return characterCount(aString, ""+aChar); + } + + public static int characterCount(String aString, String aChar) { + int aLength = aString.length(); + int aFound = 0; + if (aLength == 0 || !aString.contains(aChar)) { + return 0; + } + else { + for (int index = 0; index < aLength; index++) { + if (aString.substring(index, index+1).equals(aChar)) { + aFound++; + } + } + return aFound; + } + } } diff --git a/src/Java/gtPlusPlus/core/util/minecraft/FluidUtils.java b/src/Java/gtPlusPlus/core/util/minecraft/FluidUtils.java index ed1cbe0c64..0ae751a20b 100644 --- a/src/Java/gtPlusPlus/core/util/minecraft/FluidUtils.java +++ b/src/Java/gtPlusPlus/core/util/minecraft/FluidUtils.java @@ -10,9 +10,7 @@ import gregtech.api.util.GT_LanguageManager; import gtPlusPlus.api.objects.Logger; import gtPlusPlus.api.objects.minecraft.FluidGT6; -import gtPlusPlus.core.fluids.GenericFluid; import gtPlusPlus.core.item.base.BaseItemComponent; -import gtPlusPlus.core.item.base.cell.BaseItemCell; import gtPlusPlus.core.item.base.cell.BaseItemPlasmaCell; import gtPlusPlus.core.material.Material; import gtPlusPlus.core.material.MaterialGenerator; @@ -93,82 +91,6 @@ public class FluidUtils { } - - /** - * @param String displayName - * @param String fluidName - * @param int meltingPointC Temp - * @param short[] rgba - * @param byte state - * States: 0 (Solid), 1 (Fluid), 2(Gas), 3(Plasma) 4(Fuel I think? Don't use.) - * - * @return short[] - */ - public static Fluid generateFluid(final String displayName, final String fluidName, final int tempK, final short[] rgba ,final int aState){ - Fluid generatedFluid = null; - switch (aState) { - case 0: { - generatedFluid = new GenericFluid(displayName, fluidName, 0, 100, tempK, 10000, false, rgba); - break; - } - default: - case 1: - case 4: { - generatedFluid = new GenericFluid(displayName, fluidName, 0, 100, tempK, 1000, false, rgba); - break; - } - case 2: { - generatedFluid = new GenericFluid(displayName, fluidName, 0, -100, tempK, 200, true, rgba); - break; - } - case 3: { - generatedFluid = new GenericFluid(displayName, fluidName, 15, -10000, tempK, 10, true, rgba); - break; - } - } - return generatedFluid; - } - /** - * - * @param String fluidName - * @param int meltingPointC Temp - * @param short[] rgba - * @param byte state - * States: 0 (Solid), 1 (Fluid), 2(Gas), 3(Plasma) 4(Fuel I think? Don't use.) - * - * @return short[] - */ - public static Fluid generateFluid(final Material material ,final int aState){ - final int tempK = material.getMeltingPointC(); - Fluid generatedFluid = null; - switch (aState) { - case 0: { - generatedFluid = new GenericFluid(material, 0, 100, tempK, 10000, false); - break; - } - default: - case 1: - case 4: { - generatedFluid = new GenericFluid(material, 0, 100, tempK, 1000, false); - break; - } - case 2: { - generatedFluid = new GenericFluid(material, 0, -100, tempK, 200, true); - break; - } - case 3: { - generatedFluid = new GenericFluid(material, 15, -10000, tempK, 10, true); - break; - } - } - return generatedFluid; - } - - - - - - public static Fluid addGtFluid(final String aName, final String aLocalized, final GT_Materials aMaterial, final int aState, final long aTemperatureK, final ItemStack aFullContainer, final ItemStack aEmptyContainer, final int aFluidAmount) { return addGtFluid(aName, aLocalized, aMaterial, aState, aTemperatureK, aFullContainer, aEmptyContainer, aFluidAmount, true); } diff --git a/src/Java/gtPlusPlus/core/util/minecraft/ItemUtils.java b/src/Java/gtPlusPlus/core/util/minecraft/ItemUtils.java index 2522ba56da..d32ff4e160 100644 --- a/src/Java/gtPlusPlus/core/util/minecraft/ItemUtils.java +++ b/src/Java/gtPlusPlus/core/util/minecraft/ItemUtils.java @@ -124,7 +124,7 @@ public class ItemUtils { final int meta) { try { Item em = null; - final Item em1 = getItem(FQRN); + final Item em1 = getItemFromFQRN(FQRN); // Utils.LOG_WARNING("Found: "+em1.getUnlocalizedName()+":"+meta); if (em1 != null) { em = em1; @@ -158,7 +158,7 @@ public class ItemUtils { if (MOD) { try { Item em = null; - final Item em1 = getItem(FQRN); + final Item em1 = getItemFromFQRN(FQRN); // Utils.LOG_WARNING("Found: "+em1.getUnlocalizedName()+":"+meta); if (em1 != null) { if (null == em) { @@ -181,7 +181,7 @@ public class ItemUtils { public static ItemStack simpleMetaStack(final String FQRN, final int meta, final int itemstackSize) { try { Item em = null; - final Item em1 = getItem(FQRN); + final Item em1 = getItemFromFQRN(FQRN); // Utils.LOG_WARNING("Found: "+em1.getUnlocalizedName()+":"+meta); if (em1 != null) { if (null == em) { @@ -233,7 +233,7 @@ public class ItemUtils { ItemStack temp; if (fqrn.toLowerCase().contains(oreDict.toLowerCase())) { final String sanitizedName = fqrn.replace(oreDict, ""); - temp = ItemUtils.getItemStack(sanitizedName, stackSize); + temp = ItemUtils.getItemStackFromFQRN(sanitizedName, stackSize); return temp; } final String[] fqrnSplit = fqrn.split(":"); @@ -258,13 +258,13 @@ public class ItemUtils { return null; } - public static Item getItem(final String fqrn) // fqrn = fully qualified resource name + public static Item getItemFromFQRN(final String fqrn) // fqrn = fully qualified resource name { final String[] fqrnSplit = fqrn.split(":"); return GameRegistry.findItem(fqrnSplit[0], fqrnSplit[1]); } - public static ItemStack getItemStack(final String fqrn, final int Size) // fqrn = fully qualified resource name + public static ItemStack getItemStackFromFQRN(final String fqrn, final int Size) // fqrn = fully qualified resource name { final String[] fqrnSplit = fqrn.split(":"); return GameRegistry.findItemStack(fqrnSplit[0], fqrnSplit[1], Size); @@ -396,6 +396,61 @@ public class ItemUtils { new BaseItemDustUnique("itemDust" + unlocalizedName, materialName, mChemForm, Colour, "Dust"), new BaseItemDustUnique("itemDustSmall" + unlocalizedName, materialName, mChemForm, Colour, "Small"), new BaseItemDustUnique("itemDustTiny" + unlocalizedName, materialName, mChemForm, Colour, "Tiny") }; + + //Generate Shaped/Shapeless Recipes + + final ItemStack normalDust = ItemUtils.getSimpleStack(output[0]); + final ItemStack smallDust = ItemUtils.getSimpleStack(output[1]); + final ItemStack tinyDust = ItemUtils.getSimpleStack(output[2]); + + + if (ItemUtils.checkForInvalidItems(tinyDust) && ItemUtils.checkForInvalidItems(normalDust)) { + if (RecipeUtils.recipeBuilder( + tinyDust, tinyDust, tinyDust, + tinyDust, tinyDust, tinyDust, + tinyDust, tinyDust, tinyDust, + normalDust)){ + Logger.WARNING("9 Tiny dust to 1 Dust Recipe: "+materialName+" - Success"); + } + else { + Logger.WARNING("9 Tiny dust to 1 Dust Recipe: "+materialName+" - Failed"); + } + + if (RecipeUtils.recipeBuilder( + normalDust, null, null, + null, null, null, + null, null, null, + ItemUtils.getSimpleStack(tinyDust, 9))){ + Logger.WARNING("9 Tiny dust from 1 Recipe: "+materialName+" - Success"); + } + else { + Logger.WARNING("9 Tiny dust from 1 Recipe: "+materialName+" - Failed"); + } + } + + if (ItemUtils.checkForInvalidItems(smallDust) && ItemUtils.checkForInvalidItems(normalDust)) { + if (RecipeUtils.recipeBuilder( + smallDust, smallDust, null, + smallDust, smallDust, null, + null, null, null, + normalDust)){ + Logger.WARNING("4 Small dust to 1 Dust Recipe: "+materialName+" - Success"); + } + else { + Logger.WARNING("4 Small dust to 1 Dust Recipe: "+materialName+" - Failed"); + } + if (RecipeUtils.recipeBuilder( + null, normalDust, null, + null, null, null, + null, null, null, + ItemUtils.getSimpleStack(smallDust, 4))){ + Logger.WARNING("4 Small dust from 1 Dust Recipe: "+materialName+" - Success"); + } + else { + Logger.WARNING("4 Small dust from 1 Dust Recipe: "+materialName+" - Failed"); + } + } + return output; } @@ -608,7 +663,7 @@ public class ItemUtils { } public static String getArrayStackNames(final ItemStack[] aStack) { - String itemNames = "Item Array: "; + String itemNames = ""; int aPos = 0; for (final ItemStack alph : aStack) { if (alph == null) { diff --git a/src/Java/gtPlusPlus/core/util/minecraft/MaterialUtils.java b/src/Java/gtPlusPlus/core/util/minecraft/MaterialUtils.java index 842b8eecb2..a7fc4507e8 100644 --- a/src/Java/gtPlusPlus/core/util/minecraft/MaterialUtils.java +++ b/src/Java/gtPlusPlus/core/util/minecraft/MaterialUtils.java @@ -348,12 +348,30 @@ public class MaterialUtils { TextureSet o = (r != null && r.isPresent() && r.get() != null) ? r.get() : null; return o;*/ } + + + + public static Materials getMaterial(String aMaterialName, String aFallbackMaterialName) { + Materials g = getMaterial(aMaterialName); + if (g == null) { + g = getMaterial(aFallbackMaterialName); + } + if (g == null) { + Logger.INFO("Failed finding material '"+aMaterialName+"' & fallback '"+aFallbackMaterialName+"', returning _NULL."); + g = Materials._NULL; + } + return g; + } public static Materials getMaterial(String aMaterialName) { Materials m = gtPlusPlus.xmod.gregtech.common.StaticFields59.getMaterial(aMaterialName); if (m == null) { m = getMaterialByName(aMaterialName); } + if (m == null) { + Logger.INFO("Failed finding material '"+aMaterialName+"', returning _NULL."); + m = Materials._NULL; + } return m; } diff --git a/src/Java/gtPlusPlus/core/util/minecraft/RecipeUtils.java b/src/Java/gtPlusPlus/core/util/minecraft/RecipeUtils.java index a5f5c778bf..774c8b6f13 100644 --- a/src/Java/gtPlusPlus/core/util/minecraft/RecipeUtils.java +++ b/src/Java/gtPlusPlus/core/util/minecraft/RecipeUtils.java @@ -5,15 +5,10 @@ import java.util.Iterator; import java.util.List; import cpw.mods.fml.common.registry.GameRegistry; - -import net.minecraft.item.Item; -import net.minecraft.item.ItemStack; -import net.minecraft.item.crafting.CraftingManager; -import net.minecraft.item.crafting.IRecipe; - import gregtech.api.enums.Materials; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Recipe.GT_Recipe_Map; import gtPlusPlus.GTplusplus; import gtPlusPlus.api.interfaces.RunnableWithInfo; import gtPlusPlus.api.objects.Logger; @@ -22,9 +17,12 @@ import gtPlusPlus.api.objects.minecraft.ShapedRecipe; import gtPlusPlus.core.handler.COMPAT_HANDLER; import gtPlusPlus.core.handler.Recipes.LateRegistrationHandler; import gtPlusPlus.core.handler.Recipes.RegistrationHandler; -import gtPlusPlus.core.lib.CORE; import gtPlusPlus.core.recipe.common.CI; import gtPlusPlus.core.util.reflect.ReflectionUtils; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.CraftingManager; +import net.minecraft.item.crafting.IRecipe; import net.minecraftforge.oredict.OreDictionary; import net.minecraftforge.oredict.ShapedOreRecipe; import net.minecraftforge.oredict.ShapelessOreRecipe; @@ -33,7 +31,8 @@ public class RecipeUtils { public static int mInvalidID = 1; public static boolean recipeBuilder(final Object slot_1, final Object slot_2, final Object slot_3, final Object slot_4, final Object slot_5, final Object slot_6, final Object slot_7, final Object slot_8, final Object slot_9, ItemStack resultItem){ - if (gtPlusPlus.GTplusplus.CURRENT_LOAD_PHASE != GTplusplus.INIT_PHASE.POST_INIT) { + //Old Debug Code, useful for finding recipes loading too early. + /*if (gtPlusPlus.GTplusplus.CURRENT_LOAD_PHASE != GTplusplus.INIT_PHASE.POST_INIT) { Logger.INFO(ReflectionUtils.getMethodName(1)); Logger.INFO(ReflectionUtils.getMethodName(2)); Logger.INFO(ReflectionUtils.getMethodName(3)); @@ -44,7 +43,7 @@ public static int mInvalidID = 1; Logger.INFO(ReflectionUtils.getMethodName(8)); Logger.INFO(ReflectionUtils.getMethodName(9)); System.exit(1); - } + }*/ if (resultItem == null){ Logger.RECIPE("[Fix] Found a recipe with an invalid output, yet had a valid inputs. Using Dummy output so recipe can be found.."); @@ -212,7 +211,7 @@ public static int mInvalidID = 1; public static boolean removeCraftingRecipe(Object x){ if (null == x){return false;} if (x instanceof String){ - final Item R = ItemUtils.getItem((String) x); + final Item R = ItemUtils.getItemFromFQRN((String) x); if (R != null){ x = R; } @@ -395,6 +394,7 @@ public static int mInvalidID = 1; else { Logger.RECIPE("[Fix] Output is Null for a recipe. Report to Alkalus."); output = ItemUtils.getItemStackOfAmountFromOreDict("sadibasdkjnad", 1); + RegistrationHandler.recipesFailed++; } } } @@ -574,5 +574,13 @@ public static int mInvalidID = 1; } + public static boolean removeGtRecipe(GT_Recipe aRecipeToRemove, GT_Recipe_Map aRecipeMap) { + if (aRecipeMap.mRecipeList.contains(aRecipeToRemove)) { + return aRecipeMap.mRecipeList.remove(aRecipeToRemove); + } + return false; + } + + } |