From 9fe3f693f1d6d015f45898818b7958b3a57a9f4a Mon Sep 17 00:00:00 2001 From: Alkalus <3060479+draknyte1@users.noreply.github.com> Date: Fri, 26 Jul 2019 04:23:36 +0100 Subject: + Added config option to adjust ingame BGM delays. (Should be working) + Added a Pest Killer for quick removal of Butterflies and Bats. + Added Hydrogen Cyanide. % Replaced existing assets for the Bat King. % Replaced Bat King Logic, it's now an offensive mob. $ Fixed Bat King model scaling. --- src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java | 10 ++++++++++ 1 file changed, 10 insertions(+) (limited to 'src/Java/gtPlusPlus/plugin/agrichem') diff --git a/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java b/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java index d515375149..fd346590d4 100644 --- a/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java +++ b/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java @@ -30,6 +30,16 @@ public class Core_Agrichem implements IPlugin { return true; } + @Override + public boolean serverStart() { + return true; + } + + @Override + public boolean serverStop() { + return true; + } + @Override public String getPluginName() { return "GT++ Agrichemistry Module"; -- cgit From f41f53aea4d42d26001572b72a1f3e40feb3f159 Mon Sep 17 00:00:00 2001 From: Alkalus <3060479+draknyte1@users.noreply.github.com> Date: Mon, 14 Oct 2019 21:19:09 +0100 Subject: + Initial work on Algae. --- .../plugin/agrichem/AlgaeDefinition.java | 60 ++++++ .../gtPlusPlus/plugin/agrichem/AlgaeUtils.java | 11 + .../gtPlusPlus/plugin/agrichem/Core_Agrichem.java | 2 + .../gtPlusPlus/plugin/agrichem/IAlgalItem.java | 12 ++ .../plugin/agrichem/item/algae/ItemAlgaeBase.java | 235 +++++++++++++++++++++ .../plugin/agrichem/logic/AlgaeGeneticData.java | 130 ++++++++++++ .../agrichem/logic/AlgaeGrowthRequirement.java | 5 + 7 files changed, 455 insertions(+) create mode 100644 src/Java/gtPlusPlus/plugin/agrichem/AlgaeDefinition.java create mode 100644 src/Java/gtPlusPlus/plugin/agrichem/AlgaeUtils.java create mode 100644 src/Java/gtPlusPlus/plugin/agrichem/IAlgalItem.java create mode 100644 src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAlgaeBase.java create mode 100644 src/Java/gtPlusPlus/plugin/agrichem/logic/AlgaeGeneticData.java create mode 100644 src/Java/gtPlusPlus/plugin/agrichem/logic/AlgaeGrowthRequirement.java (limited to 'src/Java/gtPlusPlus/plugin/agrichem') diff --git a/src/Java/gtPlusPlus/plugin/agrichem/AlgaeDefinition.java b/src/Java/gtPlusPlus/plugin/agrichem/AlgaeDefinition.java new file mode 100644 index 0000000000..c6e98581ff --- /dev/null +++ b/src/Java/gtPlusPlus/plugin/agrichem/AlgaeDefinition.java @@ -0,0 +1,60 @@ +package gtPlusPlus.plugin.agrichem; + +public enum AlgaeDefinition { + + /* + * In general, the productivity of freshwater algae is primarily limited by + * the availability of the nutrient phosphate (PO4-3), while that of + * marine algae is limited by nitrate (NO3-) or ammonium (NH4+). + * Some algal species, however, may have unusual nutrient requirements, + * and their productivity may be limited by certain micronutrients, + * such as silica, in the case of diatoms. + */ + + Euglenophyta("Euglenophyta", "Euglenoids", true, false, getRGB(147, 168, 50)), + Chrysophyta("Chrysophyta", "Golden-Brown Algae", true, true, getRGB(186, 146, 0)), + Pyrrophyta("Pyrrophyta", "Fire Algae", true, true, getRGB(250, 118, 2)), + Chlorophyta("Chlorophyta", "Green Algae", true, true, getRGB(99, 181, 62)), + Rhodophyta("Rhodophyta", "Red Algae", false, true, getRGB(153, 5, 22)), + Paeophyta("Paeophyta", "Brown Algae", false, true, getRGB(94, 78, 47)), + Xanthophyta("Xanthophyta", "Yellow-Green Algae", true, false, getRGB(118, 138, 16)); + + public final String mScientificName; + public final String mSimpleName; + public final boolean mSaltWater; + public final boolean mFreshWater; + public final int mColour; + + AlgaeDefinition(String aScientificName, String aSimpleName, boolean aFresh, boolean aSalt, int aColour) { + mScientificName = aScientificName; + mSimpleName = aSimpleName; + mFreshWater = aFresh; + mSaltWater = aSalt; + mColour = aColour; + } + + public static AlgaeDefinition getByIndex(int aIndex) { + switch(aIndex) { + default: + case 0: + return Euglenophyta; + case 1: + return Chrysophyta; + case 2: + return Pyrrophyta; + case 3: + return Chlorophyta; + case 4: + return Rhodophyta; + case 5: + return Paeophyta; + case 6: + return Xanthophyta; + } + } + + private final static int getRGB(int r, int g, int b) { + return AlgaeUtils.rgbtoHexValue(r, g, b); + } + +} diff --git a/src/Java/gtPlusPlus/plugin/agrichem/AlgaeUtils.java b/src/Java/gtPlusPlus/plugin/agrichem/AlgaeUtils.java new file mode 100644 index 0000000000..73ff23888c --- /dev/null +++ b/src/Java/gtPlusPlus/plugin/agrichem/AlgaeUtils.java @@ -0,0 +1,11 @@ +package gtPlusPlus.plugin.agrichem; + +import gtPlusPlus.core.util.Utils; + +public class AlgaeUtils { + + public static int rgbtoHexValue(final int r, final int g, final int b) { + return Utils.rgbtoHexValue(r, g, b); + } + +} diff --git a/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java b/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java index fd346590d4..316e1cc143 100644 --- a/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java +++ b/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java @@ -2,6 +2,7 @@ package gtPlusPlus.plugin.agrichem; import gtPlusPlus.api.interfaces.IPlugin; import gtPlusPlus.plugin.agrichem.fluids.FluidLoader; +import gtPlusPlus.plugin.agrichem.item.algae.ItemAlgaeBase; import gtPlusPlus.plugin.manager.Core_Manager; public class Core_Agrichem implements IPlugin { @@ -17,6 +18,7 @@ public class Core_Agrichem implements IPlugin { @Override public boolean preInit() { FluidLoader.generate(); + new ItemAlgaeBase(); return true; } diff --git a/src/Java/gtPlusPlus/plugin/agrichem/IAlgalItem.java b/src/Java/gtPlusPlus/plugin/agrichem/IAlgalItem.java new file mode 100644 index 0000000000..fada07d062 --- /dev/null +++ b/src/Java/gtPlusPlus/plugin/agrichem/IAlgalItem.java @@ -0,0 +1,12 @@ +package gtPlusPlus.plugin.agrichem; + +import gtPlusPlus.plugin.agrichem.logic.AlgaeGeneticData; +import net.minecraft.item.ItemStack; + +public interface IAlgalItem { + + public abstract AlgaeDefinition getAlgaeType(ItemStack aStack); + + public abstract AlgaeGeneticData getSpeciesData(ItemStack aStack); + +} diff --git a/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAlgaeBase.java b/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAlgaeBase.java new file mode 100644 index 0000000000..6b31a42809 --- /dev/null +++ b/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAlgaeBase.java @@ -0,0 +1,235 @@ +package gtPlusPlus.plugin.agrichem.item.algae; + +import java.util.List; + +import cpw.mods.fml.common.registry.GameRegistry; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.plugin.agrichem.AlgaeDefinition; +import gtPlusPlus.plugin.agrichem.IAlgalItem; +import gtPlusPlus.plugin.agrichem.logic.AlgaeGeneticData; +import gtPlusPlus.plugin.agrichem.logic.AlgaeGrowthRequirement; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.EnumRarity; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; + +public class ItemAlgaeBase extends Item implements IAlgalItem { + + protected IIcon base; + protected IIcon overlay; + + public ItemAlgaeBase() { + this.setHasSubtypes(true); + this.setMaxDamage(127); + this.setNoRepair(); + this.setMaxStackSize(32); + this.setUnlocalizedName("BasicAlgaeItem"); + GameRegistry.registerItem(this, this.getUnlocalizedName()); + } + + @Override + public boolean isDamageable() { + return false; + } + + @Override + public boolean shouldRotateAroundWhenRendering() { + return super.shouldRotateAroundWhenRendering(); + } + + @Override + public void onUpdate(ItemStack p_77663_1_, World p_77663_2_, Entity p_77663_3_, int p_77663_4_, boolean p_77663_5_) { + if (!p_77663_1_.hasTagCompound() || p_77663_1_.getTagCompound().hasNoTags()) { + p_77663_1_ = initNBT(p_77663_1_); + } + super.onUpdate(p_77663_1_, p_77663_2_, p_77663_3_, p_77663_4_, p_77663_5_); + } + + @Override + public String getItemStackDisplayName(ItemStack aStack) { + return EnumChatFormatting.UNDERLINE+super.getItemStackDisplayName(aStack); + } + + @Override + public void addInformation(ItemStack aStack, EntityPlayer p_77624_2_, List aList, boolean p_77624_4_) { + int aDam = aStack.getItemDamage(); + try { + aList.add(AlgaeDefinition.getByIndex(aDam).mSimpleName); + if (!aStack.hasTagCompound() || aStack.getTagCompound().hasNoTags()) { + aStack = initNBT(aStack); + } + else { + NBTTagCompound aNBT = aStack.getTagCompound(); + boolean mRequiresLight = aNBT.getBoolean("mRequiresLight"); + boolean mSaltWater = aNBT.getBoolean("mSaltWater"); + boolean mFreshWater = aNBT.getBoolean("mFreshWater"); + byte mTempTolerance = aNBT.getByte("mTempTolerance"); + float mFertility = aNBT.getFloat("mFertility"); + float mProductionSpeed = aNBT.getFloat("mProductionSpeed"); + byte mLifespan = aNBT.getByte("mLifespan"); + int mGeneration = aNBT.getInteger("mGeneration"); + + aList.add("Requires Light: "+mRequiresLight); + aList.add("Salt Water: "+mSaltWater); + aList.add("Fresh Water: "+mFreshWater); + aList.add("Temp Tolerance: "+mTempTolerance); + aList.add("Growth: "+mFertility); + aList.add("Production: "+mProductionSpeed); + aList.add("Lifespan in days: "+mLifespan); + aList.add("Generation: "+mGeneration); + } + } + catch (Throwable t) { + t.printStackTrace(); + } + super.addInformation(aStack, p_77624_2_, aList, p_77624_4_); + } + + @Override + public EnumRarity getRarity(ItemStack p_77613_1_) { + return EnumRarity.uncommon; + } + + @Override + public boolean requiresMultipleRenderPasses() { + return true; + } + + @Override + public void getSubItems(Item aItem, CreativeTabs p_150895_2_, List aList) { + for (int i=0;i 5) { + aGenes = new AlgaeGeneticData(); + aTag = aGenes.writeToNBT(); + } + else { + byte aTemp, aLifespan; + float aFert, aSpeed; + + int aDam = aStack.getItemDamage(); + aTemp = (byte) (aDam == 3 ? 0 : aDam == 4 ? 2 : 1); + aLifespan = (byte) (aDam == 3 ? 1 : aDam == 4 ? 3f : 2f); + aFert = (float) (aDam == 3 ? 2f : aDam == 4 ? 1f : 1.75f); + aSpeed = (float) (aDam == 3 ? 1f : aDam == 4 ? 1.5f : 2f); + + aGenes = new AlgaeGeneticData( + true, true, + AlgaeDefinition.getByIndex(aDam).mSaltWater, AlgaeDefinition.getByIndex(aDam).mFreshWater, + aTemp, + aFert, + aSpeed, + aLifespan, + 0, + new AutoMap()); + aTag = aGenes.writeToNBT(); + } + } + else { + aTag = aStack.getTagCompound(); + } + + + + + return new AlgaeGeneticData(aTag); + } + + + + +} diff --git a/src/Java/gtPlusPlus/plugin/agrichem/logic/AlgaeGeneticData.java b/src/Java/gtPlusPlus/plugin/agrichem/logic/AlgaeGeneticData.java new file mode 100644 index 0000000000..dfe0f50b47 --- /dev/null +++ b/src/Java/gtPlusPlus/plugin/agrichem/logic/AlgaeGeneticData.java @@ -0,0 +1,130 @@ +package gtPlusPlus.plugin.agrichem.logic; + +import gtPlusPlus.api.objects.data.AutoMap; +import net.minecraft.nbt.NBTTagCompound; + +public class AlgaeGeneticData { + + private final int mLifespan; + + private final int mGeneration; + + private final boolean mIsDominant; + + private final boolean mRequiresLight; + + private final boolean mSaltWater; + + private final boolean mFreshWater; + + private final byte mTempTolerance; + + private final float mFertility; + + private final float mProductionSpeed; + + private final AutoMap mSpecialRequirements; + + + public AlgaeGeneticData() { + this(true, true, true, true, (byte) 0, 1f, 1f, (byte) 30, 0, new AutoMap()); + } + + public AlgaeGeneticData(boolean isDominant, boolean requiresLight, boolean isSalt, boolean isFresh, + byte aTempTolerance, float aFertility, float aSpeed, byte aLifespan, int aGeneration, AutoMap aRequirements) { + mIsDominant = isDominant; + mRequiresLight = requiresLight; + mSaltWater = isSalt; + mFreshWater = isFresh; + mTempTolerance = aTempTolerance; + mFertility = aFertility; + mProductionSpeed = aSpeed; + mLifespan = aLifespan; + mGeneration = aGeneration; + mSpecialRequirements = aRequirements; + } + + + public AlgaeGeneticData(NBTTagCompound aNBT) { + if (aNBT == null || aNBT.hasNoTags()) { + mIsDominant = true; + mRequiresLight = true; + mSaltWater = true; + mFreshWater = true; + mTempTolerance = 0; + mFertility = 1; + mProductionSpeed = 1; + mLifespan = 30; + mGeneration = 0; + } + else { + mIsDominant = aNBT.getBoolean("mIsDominant"); + mRequiresLight = aNBT.getBoolean("mRequiresLight"); + mSaltWater = aNBT.getBoolean("mSaltWater"); + mFreshWater = aNBT.getBoolean("mFreshWater"); + mTempTolerance = aNBT.getByte("mTempTolerance"); + mFertility = aNBT.getFloat("mFertility"); + mProductionSpeed = aNBT.getFloat("mProductionSpeed"); + mLifespan = aNBT.getByte("mLifespan"); + mGeneration = aNBT.getInteger("mGeneration"); + } + mSpecialRequirements = new AutoMap(); + } + + /** + * In MC Days + */ + public final int getLifespan() { + return this.mLifespan; + } + + public final boolean isDominant() { + return this.mIsDominant; + } + + public final boolean RequiresLight() { + return this.mRequiresLight; + } + + public final boolean isSaltWater() { + return this.mSaltWater; + } + + public final boolean isFreshWater() { + return this.mFreshWater; + } + + public final byte getTempTolerance() { + return this.mTempTolerance; + } + + public final float getFertility() { + return this.mFertility; + } + + public final float getProductionSpeed() { + return this.mProductionSpeed; + } + + public final int getGeneration() { + return this.mGeneration; + } + + public final AutoMap getSpecialRequirements() { + return this.mSpecialRequirements; + } + + public NBTTagCompound writeToNBT() { + NBTTagCompound aGenes = new NBTTagCompound(); + aGenes.setBoolean("mIsDominant", this.mIsDominant); + aGenes.setBoolean("mRequiresLight", this.mRequiresLight); + aGenes.setBoolean("mSaltWater", this.mSaltWater); + aGenes.setBoolean("mFreshWater", this.mFreshWater); + aGenes.setInteger("mLifespan", this.mLifespan); + aGenes.setInteger("mGeneration", this.mGeneration); + aGenes.setByte("mTempTolerance", this.mTempTolerance); + aGenes.setFloat("mFertility", this.mFertility); + aGenes.setFloat("mProductionSpeed", this.mProductionSpeed); + return aGenes; + } +} diff --git a/src/Java/gtPlusPlus/plugin/agrichem/logic/AlgaeGrowthRequirement.java b/src/Java/gtPlusPlus/plugin/agrichem/logic/AlgaeGrowthRequirement.java new file mode 100644 index 0000000000..6bddc9d085 --- /dev/null +++ b/src/Java/gtPlusPlus/plugin/agrichem/logic/AlgaeGrowthRequirement.java @@ -0,0 +1,5 @@ +package gtPlusPlus.plugin.agrichem.logic; + +public class AlgaeGrowthRequirement { + +} -- cgit From 351b0e3bda46103d43890cd5313bbb9b19ab0872 Mon Sep 17 00:00:00 2001 From: Alkalus <3060479+draknyte1@users.noreply.github.com> Date: Wed, 16 Oct 2019 16:49:24 +0100 Subject: + Added some new items for Biochem recipes. --- .../gtPlusPlus/plugin/agrichem/Core_Agrichem.java | 2 + .../plugin/agrichem/block/AgrichemFluids.java | 26 ++++ .../agrichem/item/algae/ItemAgrichemBase.java | 169 +++++++++++++++++++++ 3 files changed, 197 insertions(+) create mode 100644 src/Java/gtPlusPlus/plugin/agrichem/block/AgrichemFluids.java create mode 100644 src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java (limited to 'src/Java/gtPlusPlus/plugin/agrichem') diff --git a/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java b/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java index 316e1cc143..894a5b2349 100644 --- a/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java +++ b/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java @@ -2,6 +2,7 @@ package gtPlusPlus.plugin.agrichem; import gtPlusPlus.api.interfaces.IPlugin; import gtPlusPlus.plugin.agrichem.fluids.FluidLoader; +import gtPlusPlus.plugin.agrichem.item.algae.ItemAgrichemBase; import gtPlusPlus.plugin.agrichem.item.algae.ItemAlgaeBase; import gtPlusPlus.plugin.manager.Core_Manager; @@ -19,6 +20,7 @@ public class Core_Agrichem implements IPlugin { public boolean preInit() { FluidLoader.generate(); new ItemAlgaeBase(); + new ItemAgrichemBase(); return true; } diff --git a/src/Java/gtPlusPlus/plugin/agrichem/block/AgrichemFluids.java b/src/Java/gtPlusPlus/plugin/agrichem/block/AgrichemFluids.java new file mode 100644 index 0000000000..ad869afc47 --- /dev/null +++ b/src/Java/gtPlusPlus/plugin/agrichem/block/AgrichemFluids.java @@ -0,0 +1,26 @@ +package gtPlusPlus.plugin.agrichem.block; + +public class AgrichemFluids { + + /* + * Saline Water - saltwater + * Sulfuric Waste Water - sulfuricapatite + * Methanol - methanol + * Hot Water - ic2hotwater + * Acetic Acid + * Propionic Acid + * Fermentation Base + * Ethylene - ethylene + * Ethanol - bioethanol + * Diluted SA - filutedsulfuricacid + * Sulfuric Acid - sulfuricacid + * Urea + * Formaldehyde - fluid.formaldehyde + * Liquid Resin + * Methane - methane + * Benzene - benzene + * Ethylbenzene - fluid.ethylbenzene + * Styrene - styrene + */ + +} diff --git a/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java b/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java new file mode 100644 index 0000000000..b636fa7006 --- /dev/null +++ b/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java @@ -0,0 +1,169 @@ +package gtPlusPlus.plugin.agrichem.item.algae; + +import java.util.List; + +import cpw.mods.fml.common.registry.GameRegistry; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.EnumRarity; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; + +public class ItemAgrichemBase extends Item { + + protected IIcon base[] = new IIcon[22]; + + /* + * 0 - Algae Biomass + * 1 - Green Algae Biomass + * 2 - Brown Algae Biomass + * 3 - Golden-Brown Algae Biomass + * 4 - Red Algae Biomass + * 5 - Cellulose Fiber + * 6 - Golden-Brown Cellulose Fiber + * 7 - Red Cellulose Fiber + * 8 - Compost + * 9 - Wood Pellet + * 10 - Wood Brick + * 11 - Cellulose Pulp + * 12 - Raw Bio Resin + * 13 - Catalyst Carrier + * 14 - Green Metal Catalyst + * 15 - Alginic Acid + * 16 - Alumina + * 17 - Aluminium Pellet + * 18 - Sodium Aluminate + * 19 - Sodium Hydroxide // Exists in Newer GT + * 20 - Sodium Carbonate + * 21 - Lithium Chloride + */ + + public ItemAgrichemBase() { + this.setHasSubtypes(true); + this.setMaxDamage(127); + this.setNoRepair(); + this.setMaxStackSize(64); + this.setUnlocalizedName("BasicAgrichemItem"); + GameRegistry.registerItem(this, this.getUnlocalizedName()); + } + + @Override + public boolean isDamageable() { + return false; + } + + @Override + public boolean shouldRotateAroundWhenRendering() { + return super.shouldRotateAroundWhenRendering(); + } + + @Override + public void onUpdate(ItemStack p_77663_1_, World p_77663_2_, Entity p_77663_3_, int p_77663_4_, boolean p_77663_5_) { + super.onUpdate(p_77663_1_, p_77663_2_, p_77663_3_, p_77663_4_, p_77663_5_); + } + + @Override + public String getItemStackDisplayName(ItemStack aStack) { + return super.getItemStackDisplayName(aStack); + } + + @Override + public void addInformation(ItemStack aStack, EntityPlayer p_77624_2_, List aList, boolean p_77624_4_) { + try { + + } + catch (Throwable t) { + t.printStackTrace(); + } + super.addInformation(aStack, p_77624_2_, aList, p_77624_4_); + } + + @Override + public EnumRarity getRarity(ItemStack p_77613_1_) { + return EnumRarity.common; + } + + @Override + public boolean requiresMultipleRenderPasses() { + return false; + } + + @Override + public void getSubItems(Item aItem, CreativeTabs p_150895_2_, List aList) { + for (int i=0;i Date: Wed, 16 Oct 2019 17:22:35 +0100 Subject: $ Fixed Localization of Agrichem items. --- .../plugin/agrichem/item/algae/ItemAgrichemBase.java | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) (limited to 'src/Java/gtPlusPlus/plugin/agrichem') diff --git a/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java b/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java index b636fa7006..7ea3f0926e 100644 --- a/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java +++ b/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java @@ -46,9 +46,9 @@ public class ItemAgrichemBase extends Item { public ItemAgrichemBase() { this.setHasSubtypes(true); - this.setMaxDamage(127); this.setNoRepair(); this.setMaxStackSize(64); + this.setMaxDamage(0); this.setUnlocalizedName("BasicAgrichemItem"); GameRegistry.registerItem(this, this.getUnlocalizedName()); } @@ -138,7 +138,7 @@ public class ItemAgrichemBase extends Item { @Override public void registerIcons(final IIconRegister u) { - for (int i=0;i<23;i++) { + for (int i=0;i Date: Wed, 16 Oct 2019 17:48:42 +0100 Subject: + Added OreDict entries for the new Biochem items. % Hide Sodium Hydroxide dust if it already exists. --- .../gtPlusPlus/plugin/agrichem/Core_Agrichem.java | 136 ++++++++++++++++++++- .../agrichem/item/algae/ItemAgrichemBase.java | 41 ++++++- 2 files changed, 174 insertions(+), 3 deletions(-) (limited to 'src/Java/gtPlusPlus/plugin/agrichem') diff --git a/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java b/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java index 894a5b2349..57c3f765a9 100644 --- a/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java +++ b/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java @@ -1,14 +1,72 @@ package gtPlusPlus.plugin.agrichem; +import java.util.List; + import gtPlusPlus.api.interfaces.IPlugin; +import gtPlusPlus.core.util.minecraft.ItemUtils; import gtPlusPlus.plugin.agrichem.fluids.FluidLoader; import gtPlusPlus.plugin.agrichem.item.algae.ItemAgrichemBase; import gtPlusPlus.plugin.agrichem.item.algae.ItemAlgaeBase; import gtPlusPlus.plugin.manager.Core_Manager; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; public class Core_Agrichem implements IPlugin { final static Core_Agrichem mInstance; + + public static Item mAlgae; + public static Item mAgrichemItem1; + + /* + * 0 - Algae Biomass + * 1 - Green Algae Biomass + * 2 - Brown Algae Biomass + * 3 - Golden-Brown Algae Biomass + * 4 - Red Algae Biomass + * 5 - Cellulose Fiber + * 6 - Golden-Brown Cellulose Fiber + * 7 - Red Cellulose Fiber + * 8 - Compost + * 9 - Wood Pellet + * 10 - Wood Brick + * 11 - Cellulose Pulp + * 12 - Raw Bio Resin + * 13 - Catalyst Carrier + * 14 - Green Metal Catalyst + * 15 - Alginic Acid + * 16 - Alumina + * 17 - Aluminium Pellet + * 18 - Sodium Aluminate + * 19 - Sodium Hydroxide // Exists in Newer GT + * 20 - Sodium Carbonate + * 21 - Lithium Chloride + */ + + public static ItemStack mAlgaeBiosmass; + public static ItemStack mGreenAlgaeBiosmass; + public static ItemStack mBrownAlgaeBiosmass; + public static ItemStack mGoldenBrownAlgaeBiosmass; + public static ItemStack mRedAlgaeBiosmass; + public static ItemStack mCelluloseFiber; + public static ItemStack mGoldenBrownCelluloseFiber; + public static ItemStack mRedCelluloseFiber; + public static ItemStack mCompost; + public static ItemStack mWoodPellet; + public static ItemStack mWoodBrick; + public static ItemStack mCellulosePulp; + public static ItemStack mRawBioResin; + public static ItemStack mCatalystCarrier; + public static ItemStack mGreenCatalyst; + public static ItemStack mAlginicAcid; + public static ItemStack mAlumina; + public static ItemStack mAluminiumPellet; + public static ItemStack mSodiumAluminate; + public static ItemStack mSodiumHydroxide; + public static ItemStack mSodiumCarbonate; + public static ItemStack mLithiumChloride; + static { mInstance = new Core_Agrichem(); @@ -19,13 +77,87 @@ public class Core_Agrichem implements IPlugin { @Override public boolean preInit() { FluidLoader.generate(); - new ItemAlgaeBase(); - new ItemAgrichemBase(); + mAlgae = new ItemAlgaeBase(); + mAgrichemItem1 = new ItemAgrichemBase(); return true; } @Override public boolean init() { + mAlgaeBiosmass = ItemUtils.simpleMetaStack(mAgrichemItem1, 0, 1); + mGreenAlgaeBiosmass = ItemUtils.simpleMetaStack(mAgrichemItem1, 1, 1); + mBrownAlgaeBiosmass = ItemUtils.simpleMetaStack(mAgrichemItem1, 2, 1); + mGoldenBrownAlgaeBiosmass = ItemUtils.simpleMetaStack(mAgrichemItem1, 3, 1); + mRedAlgaeBiosmass = ItemUtils.simpleMetaStack(mAgrichemItem1, 4, 1); + mCelluloseFiber = ItemUtils.simpleMetaStack(mAgrichemItem1, 5, 1); + mGoldenBrownCelluloseFiber = ItemUtils.simpleMetaStack(mAgrichemItem1, 6, 1); + mRedCelluloseFiber = ItemUtils.simpleMetaStack(mAgrichemItem1, 7, 1); + mCompost = ItemUtils.simpleMetaStack(mAgrichemItem1, 8, 1); + mWoodPellet = ItemUtils.simpleMetaStack(mAgrichemItem1, 9, 1); + mWoodBrick = ItemUtils.simpleMetaStack(mAgrichemItem1, 10, 1); + mCellulosePulp = ItemUtils.simpleMetaStack(mAgrichemItem1, 11, 1); + mRawBioResin = ItemUtils.simpleMetaStack(mAgrichemItem1, 12, 1); + mCatalystCarrier = ItemUtils.simpleMetaStack(mAgrichemItem1, 13, 1); + mGreenCatalyst = ItemUtils.simpleMetaStack(mAgrichemItem1, 14, 1); + mAlginicAcid = ItemUtils.simpleMetaStack(mAgrichemItem1, 15, 1); + mAlumina = ItemUtils.simpleMetaStack(mAgrichemItem1, 16, 1); + mAluminiumPellet = ItemUtils.simpleMetaStack(mAgrichemItem1, 17, 1); + mSodiumAluminate = ItemUtils.simpleMetaStack(mAgrichemItem1, 18, 1); + + /** + * If It exists, don't add a new one. + */ + if (OreDictionary.doesOreNameExist("dustSodiumHydroxide_GT5U") || OreDictionary.doesOreNameExist("dustSodiumHydroxide")) { + List aTest = OreDictionary.getOres("dustSodiumHydroxide", false); + ItemStack aTestStack; + if (aTest.isEmpty()) { + aTest = OreDictionary.getOres("dustSodiumHydroxide_GT5U", false); + if (aTest.isEmpty()) { + aTestStack = ItemUtils.simpleMetaStack(mAgrichemItem1, 19, 1); + } + else { + aTestStack = aTest.get(0); + } + } + else { + aTestStack = aTest.get(0); + } + mSodiumHydroxide = aTestStack; + } + else { + mSodiumHydroxide = ItemUtils.simpleMetaStack(mAgrichemItem1, 19, 1); + } + mSodiumCarbonate = ItemUtils.simpleMetaStack(mAgrichemItem1, 20, 1); + mLithiumChloride = ItemUtils.simpleMetaStack(mAgrichemItem1, 21, 1); + + ItemUtils.addItemToOreDictionary(mGreenAlgaeBiosmass, "biomassGreenAlgae"); + ItemUtils.addItemToOreDictionary(mBrownAlgaeBiosmass, "biomassBrownAlgae"); + ItemUtils.addItemToOreDictionary(mGoldenBrownAlgaeBiosmass, "biomassGoldenBrownAlgae"); + ItemUtils.addItemToOreDictionary(mRedAlgaeBiosmass, "biomassRedAlgae"); + + ItemUtils.addItemToOreDictionary(mCelluloseFiber, "fiberCellulose"); + ItemUtils.addItemToOreDictionary(mGoldenBrownCelluloseFiber, "fiberCellulose"); + ItemUtils.addItemToOreDictionary(mGoldenBrownCelluloseFiber, "fiberGoldenBrownCellulose"); + ItemUtils.addItemToOreDictionary(mRedCelluloseFiber, "fiberCellulose"); + ItemUtils.addItemToOreDictionary(mRedCelluloseFiber, "fiberRedCellulose"); + + ItemUtils.addItemToOreDictionary(mWoodPellet, "pelletWood"); + ItemUtils.addItemToOreDictionary(mWoodBrick, "brickWood"); + ItemUtils.addItemToOreDictionary(mCellulosePulp, "pulpCellulose"); + + ItemUtils.addItemToOreDictionary(mCatalystCarrier, "catalystEmpty"); + ItemUtils.addItemToOreDictionary(mGreenCatalyst, "catalystAluminiumSilver"); + ItemUtils.addItemToOreDictionary(mAlginicAcid, "dustAlginicAcid"); + ItemUtils.addItemToOreDictionary(mAlumina, "dustAlumina"); + ItemUtils.addItemToOreDictionary(mAluminiumPellet, "pelletAluminium"); + + ItemUtils.addItemToOreDictionary(mSodiumAluminate, "dustSodiumAluminate"); + if (mSodiumHydroxide.getItem() instanceof ItemAgrichemBase) { + ItemUtils.addItemToOreDictionary(mSodiumHydroxide, "dustSodiumHydroxide"); + } + ItemUtils.addItemToOreDictionary(mSodiumCarbonate, "dustSodiumCarbonate"); + ItemUtils.addItemToOreDictionary(mLithiumChloride, "dustLithiumChloride"); + return true; } diff --git a/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java b/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java index 7ea3f0926e..14d15fdfa1 100644 --- a/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java +++ b/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java @@ -14,6 +14,7 @@ import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.util.IIcon; import net.minecraft.world.World; +import net.minecraftforge.oredict.OreDictionary; public class ItemAgrichemBase extends Item { @@ -94,10 +95,48 @@ public class ItemAgrichemBase extends Item { return false; } + private static boolean mHasCheckedForSodiumHydroxide = false; + private static boolean mShowSodiumHydroxide = true; + + private static boolean checkSodiumHydroxide() { + if (mHasCheckedForSodiumHydroxide) { + return mShowSodiumHydroxide; + } + else { + if (OreDictionary.doesOreNameExist("dustSodiumHydroxide_GT5U") + || OreDictionary.doesOreNameExist("dustSodiumHydroxide")) { + List aTest = OreDictionary.getOres( + "dustSodiumHydroxide", false + ); + if (aTest.isEmpty()) { + aTest = OreDictionary.getOres( + "dustSodiumHydroxide_GT5U", false + ); + if (!aTest.isEmpty()) { + mShowSodiumHydroxide = false; + } + } + else { + mShowSodiumHydroxide = false; + } + } + } + mHasCheckedForSodiumHydroxide = true; + return mShowSodiumHydroxide; + } + @Override public void getSubItems(Item aItem, CreativeTabs p_150895_2_, List aList) { for (int i=0;i Date: Wed, 16 Oct 2019 20:37:36 +0100 Subject: + Added first batch of Bio Recipes. % Updated some Textures. --- .../gtPlusPlus/plugin/agrichem/BioRecipes.java | 523 +++++++++++++++++++++ .../gtPlusPlus/plugin/agrichem/Core_Agrichem.java | 19 +- .../plugin/agrichem/block/AgrichemFluids.java | 46 ++ .../plugin/agrichem/item/algae/ItemBioChip.java | 138 ++++++ 4 files changed, 723 insertions(+), 3 deletions(-) create mode 100644 src/Java/gtPlusPlus/plugin/agrichem/BioRecipes.java create mode 100644 src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemBioChip.java (limited to 'src/Java/gtPlusPlus/plugin/agrichem') diff --git a/src/Java/gtPlusPlus/plugin/agrichem/BioRecipes.java b/src/Java/gtPlusPlus/plugin/agrichem/BioRecipes.java new file mode 100644 index 0000000000..b6e4ce8881 --- /dev/null +++ b/src/Java/gtPlusPlus/plugin/agrichem/BioRecipes.java @@ -0,0 +1,523 @@ +package gtPlusPlus.plugin.agrichem; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_ModHandler.RecipeBits; +import gtPlusPlus.core.item.chemistry.AgriculturalChem; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.lib.LoadedMods; +import gtPlusPlus.core.material.MISC_MATERIALS; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.RecipeUtils; +import gtPlusPlus.plugin.agrichem.block.AgrichemFluids; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; +import gtPlusPlus.xmod.railcraft.utils.RailcraftUtils; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; + +public class BioRecipes { + + private static Item mFert; + private static Item mDustDirt; + + private static Fluid mSalineWater; + private static Fluid mDistilledWater; + private static Fluid mThermalWater; + private static Fluid mAir; + private static Fluid mSulfuricWasteWater; + private static Fluid mAmmonia; + private static Fluid mMethanol; + private static Fluid mAceticAcid; + private static Fluid mPropionicAcid; + private static Fluid mLiquidPlastic; + private static Fluid mFermentationBase; + private static Fluid mCarbonDioxide; + private static Fluid mCarbonMonoxide; + private static Fluid mEthylene; + private static Fluid mEthanol; + private static Fluid mChlorine; + private static Fluid mHydrogen; + private static Fluid mDilutedSulfuricAcid; + private static Fluid mSulfuricAcid; + private static Fluid mUrea; + private static Fluid mFormaldehyde; + private static Fluid mLiquidResin; + private static Fluid mMethane; + private static Fluid mBenzene; + private static Fluid mEthylbenzene; + private static Fluid mStyrene; + + + private static final ItemStack getGreenAlgaeRecipeChip() { + return getBioChip(4); + } + private static final ItemStack getBrownAlgaeRecipeChip() { + return getBioChip(8); + } + private static final ItemStack getGoldenBrownAlgaeRecipeChip() { + return getBioChip(12); + } + private static final ItemStack getRedAlgaeRecipeChip() { + return getBioChip(16); + } + + private static final ItemStack getBioChip(int aID) { + return ItemUtils.simpleMetaStack(Core_Agrichem.mBioCircuit, aID, 0); + } + + public static void init() { + Core_Agrichem.mInstance.log("Setting Variables"); + initRecipeVars(); + Core_Agrichem.mInstance.log("Generating Biochip Recipes"); + recipeBioChip(); + Core_Agrichem.mInstance.log("Generating Recipes"); + recipeAlgaeBiomass(); + Core_Agrichem.mInstance.log("Finished with recipes"); + } + + private static final void initRecipeVars() { + mFert = AgriculturalChem.dustOrganicFertilizer; + mDustDirt = AgriculturalChem.dustDirt; + + + mDistilledWater = FluidUtils.getDistilledWater(1).getFluid(); + mSalineWater = FluidUtils.getFluidStack("saltwater", 1).getFluid(); + mThermalWater = FluidUtils.getFluidStack("ic2hotwater", 1).getFluid(); + mAir = FluidUtils.getFluidStack("air", 1).getFluid(); + mSulfuricWasteWater = FluidUtils.getFluidStack("sulfuricapatite", 1).getFluid(); + mAmmonia = MISC_MATERIALS.AMMONIA.getFluid(1).getFluid(); + mEthylene = FluidUtils.getFluidStack("ethylene", 1).getFluid(); + mEthanol = FluidUtils.getFluidStack("bioethanol", 1).getFluid(); + mDilutedSulfuricAcid = FluidUtils.getFluidStack("dilutedsulfuricacid", 1).getFluid(); + mSulfuricAcid = FluidUtils.getFluidStack("sulfuricacid", 1).getFluid(); + mFormaldehyde = FluidUtils.getFluidStack("fluid.formaldehyde", 1).getFluid(); + mMethane = FluidUtils.getFluidStack("methane", 1).getFluid(); + mBenzene = FluidUtils.getFluidStack("benzene", 1).getFluid(); + mEthylbenzene = FluidUtils.getFluidStack("fluid.ethylbenzene", 1).getFluid(); + mStyrene = FluidUtils.getFluidStack("styrene", 1).getFluid(); + mMethanol = FluidUtils.getFluidStack("methanol", 1).getFluid(); + mLiquidPlastic = FluidUtils.getFluidStack("plastic", 1).getFluid(); + mCarbonDioxide = MISC_MATERIALS.CARBON_DIOXIDE.getFluid(1).getFluid(); + mCarbonMonoxide = MISC_MATERIALS.CARBON_MONOXIDE.getFluid(1).getFluid(); + mChlorine = FluidUtils.getFluidStack("chlorine", 1).getFluid(); + mHydrogen = FluidUtils.getFluidStack("hydrogen", 1).getFluid(); + mAceticAcid = AgrichemFluids.mAceticAcid; + mPropionicAcid = AgrichemFluids.mPropionicAcid; + mUrea = AgrichemFluids.mUrea; + mLiquidResin = AgrichemFluids.mLiquidResin; + mFermentationBase = AgrichemFluids.mFermentationBase; + + + + } + + private static void recipeAlgaeBiomass() { + + // TODO + // Add in recipes to get initial Biomass + + recipeGreenAlgae(); + recipeBrownAlgae(); + recipeGoldenBrownAlgae(); + recipeRedAlgae(); + recipeWoodPellets(); + recipeWoodBricks(); + recipeCellulosePulp(); + recipeCatalystCarrier(); + recipeAluminiumSilverCatalyst(); + recipeAceticAcid(); + recipePropionicAcid(); + recipeFermentationBase(); + recipeEthanol(); + recipeCelluloseFibre(); + recipeGoldenBrownCelluloseFiber(); + recipeRedCelluloseFiber(); + recipeSodiumHydroxide(); + recipeSodiumCarbonate(); + recipeAluminiumPellet(); + recipeAlumina(); + recipeAluminium(); + recipeCalciumCarbonate(); + recipeLithiumChloride(); + recipeAlginicAcid(); + recipeSulfuricAcid(); + recipeUrea(); + recipeRawBioResin(); + recipeLiquidResin(); + recipeCompost(); + recipeMethane(); + recipeBenzene(); + recipeStyrene(); + } + + private static void recipeGreenAlgae() { + // Compost + GT_ModHandler.addPulverisationRecipe( + ItemUtils.getSimpleStack(Core_Agrichem.mGreenAlgaeBiosmass, 10), + ItemUtils.getSimpleStack(Core_Agrichem.mCompost, 1)); + + // Turn into Cellulose + CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] { + getGreenAlgaeRecipeChip(), + ItemUtils.getSimpleStack(Core_Agrichem.mGreenAlgaeBiosmass, 30) + }, + GT_Values.NF, + ItemUtils.getSimpleStack(Core_Agrichem.mCelluloseFiber, 5), + 20 * 30, + 16); + + + } + + private static void recipeBrownAlgae() { + // Compost + GT_ModHandler.addPulverisationRecipe( + ItemUtils.getSimpleStack(Core_Agrichem.mBrownAlgaeBiosmass, 10), + ItemUtils.getSimpleStack(Core_Agrichem.mCompost, 1)); + + // Alginic acid + GT_Values.RA.addExtractorRecipe( + ItemUtils.getSimpleStack(Core_Agrichem.mBrownAlgaeBiosmass, 10), + ItemUtils.getSimpleStack(Core_Agrichem.mAlginicAcid, 1), + 20 * 15, + 30); + + // Lithium Chloride + GT_Values.RA.addBlastRecipe( + getBrownAlgaeRecipeChip(), + ItemUtils.getSimpleStack(Core_Agrichem.mBrownAlgaeBiosmass, 20), + GT_Values.NF, + GT_Values.NF, + ItemUtils.getSimpleStack(Core_Agrichem.mLithiumChloride, 1), + GT_Values.NI, + 120, + 120, + 1200); + + // Sodium Carbonate + CORE.RA.addChemicalRecipe( + getBrownAlgaeRecipeChip(), + ItemUtils.getSimpleStack(Core_Agrichem.mBrownAlgaeBiosmass, 20), + FluidUtils.getDistilledWater(2000), + GT_Values.NF, + ItemUtils.getSimpleStack(Core_Agrichem.mSodiumCarbonate, 1), + 20 * 30, + 30); + + } + + private static void recipeGoldenBrownAlgae() { + // Compost + GT_ModHandler.addPulverisationRecipe( + ItemUtils.getSimpleStack(Core_Agrichem.mGoldenBrownAlgaeBiosmass, 10), + ItemUtils.getSimpleStack(Core_Agrichem.mCompost, 1)); + + // Turn into Cellulose + CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] { + getGoldenBrownAlgaeRecipeChip(), + ItemUtils.getSimpleStack(Core_Agrichem.mGoldenBrownAlgaeBiosmass, 30) + }, + GT_Values.NF, + ItemUtils.getSimpleStack(Core_Agrichem.mGoldenBrownCelluloseFiber, 5), + 20 * 30, + 64); + + } + + private static void recipeRedAlgae() { + // Compost + GT_ModHandler.addPulverisationRecipe( + ItemUtils.getSimpleStack(Core_Agrichem.mRedAlgaeBiosmass, 10), + ItemUtils.getSimpleStack(Core_Agrichem.mCompost, 1)); + + // Turn into Cellulose + CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] { + getRedAlgaeRecipeChip(), + ItemUtils.getSimpleStack(Core_Agrichem.mRedAlgaeBiosmass, 30) + }, + GT_Values.NF, + ItemUtils.getSimpleStack(Core_Agrichem.mRedCelluloseFiber, 5), + 20 * 30, + 256); + + } + + private static void recipeCelluloseFibre() { + + CORE.RA.addChemicalRecipe( + ItemUtils.getSimpleStack(Core_Agrichem.mCelluloseFiber, 20), + ItemUtils.getSimpleStack(Core_Agrichem.mAlginicAcid, 2), + GT_Values.NF, + GT_Values.NF, + ItemUtils.getSimpleStack(Core_Agrichem.mCellulosePulp, 10), + 30 * 20, + 16); + + // Craft into Wood Pellets + CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] { + getBioChip(2), + ItemUtils.getSimpleStack(Core_Agrichem.mCelluloseFiber, 12) + }, + GT_Values.NF, + ItemUtils.getSimpleStack(Core_Agrichem.mWoodPellet, 2), + 20 * 30, + 30); + + // Methanol Extraction + GT_Values.RA.addFluidExtractionRecipe( + ItemUtils.getSimpleStack(Core_Agrichem.mCelluloseFiber, 12), + GT_Values.NI, + FluidUtils.getFluidStack(mMethanol, 50), + 10000, + 20 * 30, + 30); + + // Compost + GT_ModHandler.addPulverisationRecipe( + ItemUtils.getSimpleStack(Core_Agrichem.mCelluloseFiber, 5), + ItemUtils.getSimpleStack(Core_Agrichem.mCompost, 1)); + + + } + + private static void recipeWoodPellets() { + // Shapeless Recipe + RecipeUtils.addShapelessGregtechRecipe(new ItemStack[] { + ItemUtils.getSimpleStack(Core_Agrichem.mWoodPellet, 1), + ItemUtils.getSimpleStack(Core_Agrichem.mWoodPellet, 1), + ItemUtils.getSimpleStack(Core_Agrichem.mWoodPellet, 1), + ItemUtils.getSimpleStack(Core_Agrichem.mWoodPellet, 1), + ItemUtils.getSimpleStack(Core_Agrichem.mWoodPellet, 1), + ItemUtils.getSimpleStack(Core_Agrichem.mWoodPellet, 1), + ItemUtils.getSimpleStack(Core_Agrichem.mWoodPellet, 1), + ItemUtils.getSimpleStack(Core_Agrichem.mWoodPellet, 1) + }, ItemUtils.getSimpleStack(Core_Agrichem.mWoodBrick, 2)); + + // Assembly Recipe + CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] { + getBioChip(2), + ItemUtils.getSimpleStack(Core_Agrichem.mWoodPellet, 8) + }, + GT_Values.NF, + ItemUtils.getSimpleStack(Core_Agrichem.mWoodBrick, 2), + 20, + 8); + + // CO2 + CORE.RA.addFluidExtractionRecipe( + GT_Values.NI, + ItemUtils.getSimpleStack(Core_Agrichem.mWoodPellet, 1), + FluidUtils.getFluidStack(mCarbonDioxide, 70), + 10*20, + 30); + + + // Add Charcoal Recipe + if (LoadedMods.Railcraft) { + RailcraftUtils.addCokeOvenRecipe( + ItemUtils.getSimpleStack(Core_Agrichem.mWoodPellet, 2), + true, + true, + ItemUtils.getItemStackOfAmountFromOreDict("gemCharcoal", 3), + GT_Values.NF, + 1200); + } + CORE.RA.addCokeOvenRecipe( + ItemUtils.getSimpleStack(Core_Agrichem.mWoodPellet, 1), + getBioChip(3), + null, + GT_Values.NF, + ItemUtils.getItemStackOfAmountFromOreDict("gemCharcoal", 3), + 120, + 16); + + + } + + private static void recipeWoodBricks() { + + // Assembly Recipe + CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] { + getBioChip(3), + ItemUtils.getOrePrefixStack(OrePrefixes.dust, Materials.Wood, 50) + }, + GT_Values.NF, + ItemUtils.getSimpleStack(Core_Agrichem.mWoodBrick, 1), + 100, + 16); + } + + private static void recipeCellulosePulp() { + + // Assembly Recipe + CORE.RA.addSixSlotAssemblingRecipe(new ItemStack[] { + getBioChip(2), + ItemUtils.getSimpleStack(Core_Agrichem.mCellulosePulp, 4) + }, + GT_Values.NF, + ItemUtils.getSimpleStack(Items.paper, 1), + 50, + 16); + } + + private static void recipeCatalystCarrier() { + + } + + private static void recipeAluminiumSilverCatalyst() { + + } + + private static void recipeAceticAcid() { + + } + + private static void recipeFermentationBase() { + + } + + private static void recipePropionicAcid() { + + } + + private static void recipeEthanol() { + + } + + private static void recipeGoldenBrownCelluloseFiber() { + + } + + private static void recipeRedCelluloseFiber() { + + } + + private static void recipeSodiumHydroxide() { + + } + + private static void recipeSodiumCarbonate() { + + } + + private static void recipeAluminiumPellet() { + + } + + private static void recipeAlumina() { + + } + + private static void recipeAluminium() { + + } + + private static void recipeCalciumCarbonate() { + + } + + private static void recipeLithiumChloride() { + + } + + private static void recipeAlginicAcid() { + + } + + private static void recipeSulfuricAcid() { + + } + + private static void recipeUrea() { + + } + + private static void recipeRawBioResin() { + + } + + private static void recipeLiquidResin() { + + } + + private static void recipeCompost() { + + } + + private static void recipeMethane() { + + } + + private static void recipeBenzene() { + + } + + private static void recipeStyrene() { + + } + + private static void recipeBioChip() { + + GT_ModHandler.addShapelessCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 0L, new Object[0]), + RecipeBits.NOT_REMOVABLE, new Object[]{OrePrefixes.circuit.get(Materials.Primitive)}); + + + long bits = RecipeBits.BUFFERED | RecipeBits.NOT_REMOVABLE; + + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 1L, new Object[0]), bits, + new Object[]{"d ", " P ", " ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 2L, new Object[0]), bits, + new Object[]{" d ", " P ", " ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 3L, new Object[0]), bits, + new Object[]{" d", " P ", " ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 4L, new Object[0]), bits, + new Object[]{" ", " Pd", " ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 5L, new Object[0]), bits, + new Object[]{" ", " P ", " d", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 6L, new Object[0]), bits, + new Object[]{" ", " P ", " d ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 7L, new Object[0]), bits, + new Object[]{" ", " P ", "d ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 8L, new Object[0]), bits, + new Object[]{" ", "dP ", " ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 9L, new Object[0]), bits, + new Object[]{"P d", " ", " ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 10L, new Object[0]), bits, + new Object[]{"P ", " d", " ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 11L, new Object[0]), bits, + new Object[]{"P ", " ", " d", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 12L, new Object[0]), bits, + new Object[]{"P ", " ", " d ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 13L, new Object[0]), bits, + new Object[]{" P", " ", " d", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 14L, new Object[0]), bits, + new Object[]{" P", " ", " d ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 15L, new Object[0]), bits, + new Object[]{" P", " ", "d ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 16L, new Object[0]), bits, + new Object[]{" P", "d ", " ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 17L, new Object[0]), bits, + new Object[]{" ", " ", "d P", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 18L, new Object[0]), bits, + new Object[]{" ", "d ", " P", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 19L, new Object[0]), bits, + new Object[]{"d ", " ", " P", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 20L, new Object[0]), bits, + new Object[]{" d ", " ", " P", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 21L, new Object[0]), bits, + new Object[]{"d ", " ", "P ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 22L, new Object[0]), bits, + new Object[]{" d ", " ", "P ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 23L, new Object[0]), bits, + new Object[]{" d", " ", "P ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 24L, new Object[0]), bits, + new Object[]{" ", " d", "P ", 'P', GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0])}); + } + + +} diff --git a/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java b/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java index 57c3f765a9..bb467699a7 100644 --- a/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java +++ b/src/Java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java @@ -4,10 +4,13 @@ import java.util.List; import gtPlusPlus.api.interfaces.IPlugin; import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.plugin.agrichem.block.AgrichemFluids; import gtPlusPlus.plugin.agrichem.fluids.FluidLoader; import gtPlusPlus.plugin.agrichem.item.algae.ItemAgrichemBase; import gtPlusPlus.plugin.agrichem.item.algae.ItemAlgaeBase; +import gtPlusPlus.plugin.agrichem.item.algae.ItemBioChip; import gtPlusPlus.plugin.manager.Core_Manager; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraftforge.oredict.OreDictionary; @@ -17,6 +20,7 @@ public class Core_Agrichem implements IPlugin { final static Core_Agrichem mInstance; public static Item mAlgae; + public static Item mBioCircuit; public static Item mAgrichemItem1; /* @@ -75,15 +79,22 @@ public class Core_Agrichem implements IPlugin { } @Override - public boolean preInit() { + public boolean preInit() { + mInstance.log("Generating Fluids"); FluidLoader.generate(); + AgrichemFluids.init(); + mInstance.log("Generating Items"); mAlgae = new ItemAlgaeBase(); mAgrichemItem1 = new ItemAgrichemBase(); + mBioCircuit = new ItemBioChip(); + mInstance.log("Setting Bio Circuit"); + GregtechItemList.Circuit_BioRecipeSelector.set(mBioCircuit); return true; } @Override public boolean init() { + mInstance.log("Setting Items"); mAlgaeBiosmass = ItemUtils.simpleMetaStack(mAgrichemItem1, 0, 1); mGreenAlgaeBiosmass = ItemUtils.simpleMetaStack(mAgrichemItem1, 1, 1); mBrownAlgaeBiosmass = ItemUtils.simpleMetaStack(mAgrichemItem1, 2, 1); @@ -130,6 +141,7 @@ public class Core_Agrichem implements IPlugin { mSodiumCarbonate = ItemUtils.simpleMetaStack(mAgrichemItem1, 20, 1); mLithiumChloride = ItemUtils.simpleMetaStack(mAgrichemItem1, 21, 1); + mInstance.log("OreDicting Items"); ItemUtils.addItemToOreDictionary(mGreenAlgaeBiosmass, "biomassGreenAlgae"); ItemUtils.addItemToOreDictionary(mBrownAlgaeBiosmass, "biomassBrownAlgae"); ItemUtils.addItemToOreDictionary(mGoldenBrownAlgaeBiosmass, "biomassGoldenBrownAlgae"); @@ -156,13 +168,14 @@ public class Core_Agrichem implements IPlugin { ItemUtils.addItemToOreDictionary(mSodiumHydroxide, "dustSodiumHydroxide"); } ItemUtils.addItemToOreDictionary(mSodiumCarbonate, "dustSodiumCarbonate"); - ItemUtils.addItemToOreDictionary(mLithiumChloride, "dustLithiumChloride"); - + ItemUtils.addItemToOreDictionary(mLithiumChloride, "dustLithiumChloride"); return true; } @Override public boolean postInit() { + mInstance.log("Generating Recipes"); + BioRecipes.init(); return true; } diff --git a/src/Java/gtPlusPlus/plugin/agrichem/block/AgrichemFluids.java b/src/Java/gtPlusPlus/plugin/agrichem/block/AgrichemFluids.java index ad869afc47..1f686cf810 100644 --- a/src/Java/gtPlusPlus/plugin/agrichem/block/AgrichemFluids.java +++ b/src/Java/gtPlusPlus/plugin/agrichem/block/AgrichemFluids.java @@ -1,5 +1,9 @@ package gtPlusPlus.plugin.agrichem.block; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; + public class AgrichemFluids { /* @@ -22,5 +26,47 @@ public class AgrichemFluids { * Ethylbenzene - fluid.ethylbenzene * Styrene - styrene */ + + public static Fluid mAceticAcid; + public static Fluid mPropionicAcid; + public static Fluid mFermentationBase; + public static Fluid mUrea; + public static Fluid mLiquidResin; + + + public static void init() { + if (!FluidRegistry.isFluidRegistered("aceticacid")) { + mAceticAcid = FluidUtils.generateFluidNoPrefix("aceticacid", "Acetic Acid", 200, new short[] { 97, 168, 96, 100 }, true); + } + else { + mAceticAcid = FluidRegistry.getFluid("aceticacid"); + } + if (!FluidRegistry.isFluidRegistered("propionicacid")) { + mPropionicAcid = FluidUtils.generateFluidNoPrefix("propionicacid", "Propionic Acid", 200, new short[] { 198, 209, 148, 100 }, true); + } + else { + mPropionicAcid = FluidRegistry.getFluid("propionicacid"); + } + if (!FluidRegistry.isFluidRegistered("fermentation.base")) { + mFermentationBase = FluidUtils.generateFluidNoPrefix("fermentation.base", "Fermentation Base", 200, new short[] { 107, 100, 63, 100 }, true); + } + else { + mFermentationBase = FluidRegistry.getFluid("fermentation.base"); + } + if (!FluidRegistry.isFluidRegistered("ureamix")) { + mUrea = FluidUtils.generateFluidNoPrefix("ureamix", "Urea Mix", 200, new short[] { 71, 55, 12, 100 }, true); + } + else { + mUrea = FluidRegistry.getFluid("ureamix"); + } + if (!FluidRegistry.isFluidRegistered("liquidresin")) { + mLiquidResin = FluidUtils.generateFluidNoPrefix("liquidresin", "Liquid Resin", 200, new short[] { 59, 58, 56, 100 }, true); + } + else { + mLiquidResin = FluidRegistry.getFluid("liquidresin"); + } + } + + } diff --git a/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemBioChip.java b/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemBioChip.java new file mode 100644 index 0000000000..5ecfbbabe9 --- /dev/null +++ b/src/Java/gtPlusPlus/plugin/agrichem/item/algae/ItemBioChip.java @@ -0,0 +1,138 @@ +package gtPlusPlus.plugin.agrichem.item.algae; + +import java.util.List; + +import cpw.mods.fml.common.registry.GameRegistry; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.EnumRarity; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; + +public class ItemBioChip extends Item { + + protected IIcon base; + + public ItemBioChip() { + this.setHasSubtypes(true); + this.setNoRepair(); + this.setMaxStackSize(64); + this.setMaxDamage(0); + this.setUnlocalizedName("BioRecipeSelector"); + GameRegistry.registerItem(this, this.getUnlocalizedName()); + } + + @Override + public boolean isDamageable() { + return false; + } + + @Override + public boolean shouldRotateAroundWhenRendering() { + return super.shouldRotateAroundWhenRendering(); + } + + @Override + public void onUpdate(ItemStack p_77663_1_, World p_77663_2_, Entity p_77663_3_, int p_77663_4_, boolean p_77663_5_) { + super.onUpdate(p_77663_1_, p_77663_2_, p_77663_3_, p_77663_4_, p_77663_5_); + } + + @Override + public String getItemStackDisplayName(ItemStack aStack) { + return super.getItemStackDisplayName(aStack); + } + + @Override + public void addInformation(ItemStack aStack, EntityPlayer p_77624_2_, List aList, boolean p_77624_4_) { + try { + aList.add("Configuration == "+aStack.getItemDamage()); + } + catch (Throwable t) { + t.printStackTrace(); + } + super.addInformation(aStack, p_77624_2_, aList, p_77624_4_); + } + + @Override + public EnumRarity getRarity(ItemStack p_77613_1_) { + return EnumRarity.common; + } + + @Override + public void getSubItems(Item aItem, CreativeTabs p_150895_2_, List aList) { + aList.add(ItemUtils.simpleMetaStack(aItem, 0, 1)); + } + + @Override + public boolean getIsRepairable(ItemStack p_82789_1_, ItemStack p_82789_2_) { + return false; + } + + @Override + public boolean isRepairable() { + return false; + } + + @Override + public boolean isBookEnchantable(ItemStack stack, ItemStack book) { + return false; + } + + @Override + public int getDisplayDamage(ItemStack stack) { + return stack.getItemDamage(); + } + + @Override + public boolean showDurabilityBar(ItemStack stack) { + return false; + } + + @Override + public int getItemEnchantability() { + return 0; + } + + @Override + public int getItemEnchantability(ItemStack stack) { + return 0; + } + + @Override + public void registerIcons(final IIconRegister u) { + this.base = u.registerIcon(CORE.MODID + ":" + "bioscience/BioCircuit"); + } + + @Override + public IIcon getIconFromDamageForRenderPass(final int damage, final int pass) { + return this.base; + } + + @Override + public IIcon getIconFromDamage(int damage) { + return this.base; + } + + @Override + public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining) { + return this.base; + } + + @Override + public IIcon getIcon(ItemStack stack, int pass) { + return this.base; + } + + @Override + public String getUnlocalizedName(ItemStack stack) { + return super.getUnlocalizedName(); + } + + +} -- cgit From 68e266e0a227aaf90294d2a8ffd5081dc3bb640e Mon Sep 17 00:00:00 2001 From: Alkalus <3060479+draknyte1@users.noreply.github.com> Date: Thu, 24 Oct 2019 00:58:51 +0100 Subject: + Added Chemical Plant. + Added more Bio Recipes. $ Fixe