diff options
Diffstat (limited to 'gtpp/src/main/java/gtPlusPlus/plugin')
16 files changed, 2568 insertions, 0 deletions
diff --git a/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeDefinition.java b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeDefinition.java new file mode 100644 index 0000000000..890a9020c9 --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeDefinition.java @@ -0,0 +1,49 @@ +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) { + return switch (aIndex) { + default -> Euglenophyta; + case 1 -> Chrysophyta; + case 2 -> Pyrrophyta; + case 3 -> Chlorophyta; + case 4 -> Rhodophyta; + case 5 -> Paeophyta; + case 6 -> Xanthophyta; + }; + } + + private static int getRGB(int r, int g, int b) { + return AlgaeUtils.rgbtoHexValue(r, g, b); + } +} diff --git a/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeUtils.java b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeUtils.java new file mode 100644 index 0000000000..4906d0483f --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeUtils.java @@ -0,0 +1,10 @@ +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/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/BioRecipes.java b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/BioRecipes.java new file mode 100644 index 0000000000..a4bbd6e03a --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/BioRecipes.java @@ -0,0 +1,1257 @@ +package gtPlusPlus.plugin.agrichem; + +import static gregtech.api.enums.Mods.Forestry; +import static gregtech.api.enums.Mods.Railcraft; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes; +import static gregtech.api.recipe.RecipeMaps.distilleryRecipes; +import static gregtech.api.recipe.RecipeMaps.extractorRecipes; +import static gregtech.api.recipe.RecipeMaps.extruderRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidExtractionRecipes; +import static gregtech.api.recipe.RecipeMaps.latheRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.recipe.RecipeMaps.multiblockChemicalReactorRecipes; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT; +import static gregtech.api.util.GT_RecipeConstants.FUEL_TYPE; +import static gregtech.api.util.GT_RecipeConstants.FUEL_VALUE; +import static gregtech.api.util.GT_RecipeConstants.UniversalChemical; +import static gtPlusPlus.api.recipe.GTPPRecipeMaps.chemicalDehydratorRecipes; +import static gtPlusPlus.api.recipe.GTPPRecipeMaps.chemicalPlantRecipes; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; + +import net.minecraft.enchantment.Enchantment; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +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; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.objects.GT_ItemStack; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeConstants; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.item.ModItems; +import gtPlusPlus.core.item.base.BaseItemComponent; +import gtPlusPlus.core.item.chemistry.AgriculturalChem; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.material.ALLOY; +import gtPlusPlus.core.material.MISC_MATERIALS; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.MaterialUtils; +import gtPlusPlus.core.util.minecraft.OreDictUtils; +import gtPlusPlus.core.util.minecraft.RecipeUtils; +import gtPlusPlus.core.util.reflect.ReflectionUtils; +import gtPlusPlus.plugin.agrichem.block.AgrichemFluids; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; +import gtPlusPlus.xmod.railcraft.utils.RailcraftUtils; +import ic2.core.Ic2Items; + +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; + public 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 Fluid mButanol; + private static Fluid mAcetone; + + private static ItemStack getGreenAlgaeRecipeChip() { + return getBioChip(4); + } + + private static ItemStack getBrownAlgaeRecipeChip() { + return getBioChip(8); + } + + private static ItemStack getGoldenBrownAlgaeRecipeChip() { + return getBioChip(12); + } + + private static ItemStack getRedAlgaeRecipeChip() { + return getBioChip(16); + } + + private static ItemStack getBioChip(int aID) { + return ItemUtils.simpleMetaStack(AgriculturalChem.mBioCircuit, aID, 0); + } + + public static void init() { + Logger.INFO("[Bio] Setting Variables"); + initRecipeVars(); + Logger.INFO("[Bio] Generating Biochip Recipes"); + recipeBioChip(); + Logger.INFO("[Bio] Generating Recipes"); + recipeAlgaeBiomass(); + Logger.INFO("[Bio] Finished with recipes"); + } + + private static void initRecipeVars() { + mFert = AgriculturalChem.dustOrganicFertilizer; + mDustDirt = AgriculturalChem.dustDirt; + + // 5.08 Salt Water Solution ;) + if (!FluidUtils.doesFluidExist("saltwater")) { + mSalineWater = FluidUtils + .generateFluidNoPrefix("saltwater", "Salt Water", 200, new short[] { 10, 30, 220, 100 }); + } else { + Materials aSaltWater = MaterialUtils.getMaterial("saltwater"); + if (aSaltWater != null) { + FluidStack aWaterStack = aSaltWater.getFluid(1); + if (aWaterStack != null) { + mSalineWater = aSaltWater.getFluid(1) + .getFluid(); + } + } + if (mSalineWater == null) { + mSalineWater = FluidUtils.getWildcardFluidStack("saltwater", 1) + .getFluid(); + } + if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cellSaltWater", 1) == null) { + new BaseItemComponent("saltwater", "Salt Water", new short[] { 10, 30, 220 }); + } + } + + mDistilledWater = FluidUtils.getDistilledWater(1) + .getFluid(); + mThermalWater = FluidUtils.getFluidStack("ic2hotwater", 1) + .getFluid(); + mAir = FluidUtils.getFluidStack("air", 1) + .getFluid(); + mSulfuricWasteWater = FluidUtils.getFluidStack("sulfuricapatite", 1) + .getFluid(); + mAmmonia = MISC_MATERIALS.AMMONIA.getFluidStack(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.getWildcardFluidStack("plastic", 1) + .getFluid(); + mCarbonDioxide = MISC_MATERIALS.CARBON_DIOXIDE.getFluidStack(1) + .getFluid(); + mCarbonMonoxide = MISC_MATERIALS.CARBON_MONOXIDE.getFluidStack(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; + mButanol = AgrichemFluids.mButanol; + mAcetone = AgrichemFluids.mAcetone; + } + + 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(); + recipePelletMold(); + recipeAluminiumPellet(); + recipeAlumina(); + recipeAluminium(); + recipeLithiumChloride(); + recipeSulfuricAcid(); + recipeUrea(); + recipeRawBioResin(); + recipeLiquidResin(); + recipeCompost(); + recipeMethane(); + recipeBenzene(); + recipeStyrene(); + registerFuels(); + } + + private static void registerFuels() { + + // Burnables + ItemUtils.registerFuel(ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), 800); + ItemUtils.registerFuel(ItemUtils.getSimpleStack(AgriculturalChem.mWoodBrick, 1), 4800); + + // Combustion Fuels + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getItemStackOfAmountFromOreDict("cellButanol", 1)) + .metadata(FUEL_VALUE, 400) + .metadata(FUEL_TYPE, 0) + .duration(0) + .eut(0) + .addTo(GT_RecipeConstants.Fuel); + } + + private static void recipeGreenAlgae() { + // Compost + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 4)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 1)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + // Turn into Cellulose + GT_Values.RA.stdBuilder() + .itemInputs(getGreenAlgaeRecipeChip(), ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 10)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 5)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(16) + .addTo(assemblerRecipes); + } + + private static void recipeBrownAlgae() { + // Compost + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 2)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 1)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + // Alginic acid + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 10)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mAlginicAcid, 2)) + .duration(2 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(extractorRecipes); + + // Lithium Chloride + GT_Values.RA.stdBuilder() + .itemInputs(getBrownAlgaeRecipeChip(), ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 20)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mLithiumChloride, 5)) + .duration(6 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 1200) + .addTo(blastFurnaceRecipes); + + // Sodium Carbonate + GT_Values.RA.stdBuilder() + .itemInputs(getBrownAlgaeRecipeChip(), ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 40)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mSodiumCarbonate, 20)) + .fluidInputs(FluidUtils.getDistilledWater(2000)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + } + + private static void recipeGoldenBrownAlgae() { + // Compost + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownAlgaeBiosmass, 1)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 1)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + // Turn into Cellulose + GT_Values.RA.stdBuilder() + .itemInputs( + getGoldenBrownAlgaeRecipeChip(), + ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownAlgaeBiosmass, 10)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownCelluloseFiber, 5)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + } + + private static void recipeRedAlgae() { + // Compost + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, 1)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 2)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + // Turn into Cellulose + GT_Values.RA.stdBuilder() + .itemInputs(getRedAlgaeRecipeChip(), ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, 10)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mRedCelluloseFiber, 5)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_HV / 2) + .addTo(assemblerRecipes); + } + + private static void recipeCelluloseFibre() { + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 8), + ItemUtils.getSimpleStack(AgriculturalChem.mAlginicAcid, 2)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCellulosePulp, 10)) + .duration(10 * SECONDS) + .eut(16) + .addTo(UniversalChemical); + + // Craft into Wood Pellets + GT_Values.RA.stdBuilder() + .itemInputs(getBioChip(2), ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 12)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 24)) + .duration(2 * SECONDS + 8 * TICKS) + .eut(8) + .addTo(assemblerRecipes); + + // Methanol Extraction + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 12)) + .fluidOutputs(Materials.Methanol.getFluid(1000L)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(fluidExtractionRecipes); + + // Compost + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 3)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 1)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + // Plastic + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(16), ItemUtils.getSimpleStack(AgriculturalChem.mCellulosePulp, 4), }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mAceticAcid, 500), + FluidUtils.getFluidStack(BioRecipes.mPropionicAcid, 500), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mLiquidPlastic, (1000)), }, + 10 * 20, + 240, + 2); + } + + private static void recipeWoodPellets() { + // Shapeless Recipe + RecipeUtils.addShapelessGregtechRecipe( + new ItemStack[] { ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1) }, + ItemUtils.getSimpleStack(AgriculturalChem.mWoodBrick, 2)); + + // Extruder Recipe + GT_Values.RA.stdBuilder() + .itemInputs( + ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 12), + ItemUtils.getSimpleStack(AgriculturalChem.mPelletMold, 0)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 3)) + .duration(10 * SECONDS) + .eut(16) + .addTo(extruderRecipes); + + // Assembly Recipe + GT_Values.RA.stdBuilder() + .itemInputs(getBioChip(2), ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 8)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mWoodBrick, 2)) + .duration(5 * SECONDS) + .eut(8) + .addTo(assemblerRecipes); + + // CO2 + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1)) + .fluidOutputs(FluidUtils.getFluidStack(mCarbonDioxide, 70)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(fluidExtractionRecipes); + + // Add Charcoal Recipe + if (Railcraft.isModLoaded()) { + RailcraftUtils.addCokeOvenRecipe( + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 2), + true, + true, + ItemUtils.getItemStackOfAmountFromOreDict("gemCharcoal", 3), + GT_Values.NF, + 1200); + } + CORE.RA.addCokeOvenRecipe( + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 2), + getBioChip(3), + null, + GT_Values.NF, + ItemUtils.getItemStackOfAmountFromOreDict("gemCharcoal", 3), + 120, + 16); + } + + private static void recipeWoodBricks() { + + // Assembler Recipe + GT_Values.RA.stdBuilder() + .itemInputs(getBioChip(3), ItemUtils.getOrePrefixStack(OrePrefixes.dust, Materials.Wood, 50)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mWoodBrick, 1)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + } + + private static void recipeCellulosePulp() { + + // Assembler Recipe + GT_Values.RA.stdBuilder() + .itemInputs(getBioChip(2), ItemUtils.getSimpleStack(AgriculturalChem.mCellulosePulp, 4)) + .itemOutputs(ItemUtils.getSimpleStack(Items.paper, 4)) + .duration(2 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + } + + private static void recipeCatalystCarrier() { + // Assembler Recipe + GT_Values.RA.stdBuilder() + .itemInputs( + getBioChip(20), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Steel, 8L), + GT_OreDictUnificator.get(OrePrefixes.wireFine, Materials.Copper, 4L), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Tin, 6L)) + .itemOutputs(CI.getEmptyCatalyst(1)) + .duration(5 * MINUTES) + .eut(16) + .addTo(assemblerRecipes); + } + + private static void recipeAluminiumSilverCatalyst() { + // Assembler Recipe + GT_Values.RA.stdBuilder() + .itemInputs( + getBioChip(4), + CI.getEmptyCatalyst(10), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Aluminium, 4L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Silver, 4L)) + .itemOutputs(CI.getGreenCatalyst(10)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + } + + private static void recipeAceticAcid() { + + // CH4O + CO = C2H4O2 + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { CI.getGreenCatalyst(0) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mMethanol, 700), + FluidUtils.getFluidStack(BioRecipes.mCarbonMonoxide, 700), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mAceticAcid, 700), }, + 120 * 20, + 60, + 1); + + GT_Values.RA.stdBuilder() + .itemInputs(CI.getNumberedBioCircuit(14)) + .fluidInputs(FluidUtils.getFluidStack(mFermentationBase, 1000)) + .fluidOutputs(FluidUtils.getFluidStack(mAceticAcid, 1000)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 2)) + .duration(60 * SECONDS) + .eut(16) + .noOptimize() + .addTo(chemicalDehydratorRecipes); + } + + public static final HashSet<GT_ItemStack> mFruits = new HashSet<>(); + public static final HashSet<GT_ItemStack> mVege = new HashSet<>(); + public static final HashSet<GT_ItemStack> mNuts = new HashSet<>(); + public static final HashSet<GT_ItemStack> mSeeds = new HashSet<>(); + + public static final AutoMap<ItemStack> mList_Master_FruitVege = new AutoMap<>(); + public static final AutoMap<ItemStack> mList_Master_Seeds = new AutoMap<>(); + + private static void processFermentationOreDict() { + processOreDictEntry("listAllfruit", mFruits); + processOreDictEntry("listAllFruit", mFruits); + processOreDictEntry("listAllveggie", mVege); + processOreDictEntry("listAllVeggie", mVege); + processOreDictEntry("listAllnut", mNuts); + processOreDictEntry("listAllNut", mNuts); + processOreDictEntry("listAllseed", mSeeds); + processOreDictEntry("listAllSeed", mSeeds); + + if (!mFruits.isEmpty()) { + for (GT_ItemStack g : mFruits) { + mList_Master_FruitVege.put(g.toStack()); + } + } + if (!mVege.isEmpty()) { + for (GT_ItemStack g : mVege) { + mList_Master_FruitVege.put(g.toStack()); + } + } + if (!mNuts.isEmpty()) { + for (GT_ItemStack g : mNuts) { + mList_Master_FruitVege.put(g.toStack()); + } + } + if (!mSeeds.isEmpty()) { + for (GT_ItemStack g : mSeeds) { + mList_Master_Seeds.put(g.toStack()); + } + } + } + + // Make Fermentation + private static void processOreDictEntry(String aOreName, HashSet<GT_ItemStack> mfruits2) { + ArrayList<ItemStack> aTemp = OreDictionary.getOres(aOreName); + if (!aTemp.isEmpty()) { + for (ItemStack stack : aTemp) { + mfruits2.add(new GT_ItemStack(stack)); + } + } + } + + private static void recipeFermentationBase() { + processFermentationOreDict(); + AutoMap<ItemStack> aFruitVege = mList_Master_FruitVege; + AutoMap<ItemStack> aSeeds = mList_Master_Seeds; + ArrayList<ItemStack> aMap = OreDictionary.getOres("cropSugarbeet"); + for (ItemStack a : aFruitVege) { + if (aMap.contains(a)) { + continue; + } + if (ItemUtils.checkForInvalidItems(a)) { + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(2), ItemUtils.getSimpleStack(a, 10) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 1000), }, + 30 * 20, + 2, + 0); + } + } + for (ItemStack a : aSeeds) { + if (ItemUtils.checkForInvalidItems(a)) { + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(3), ItemUtils.getSimpleStack(a, 20) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 1000), }, + 30 * 20, + 2, + 0); + } + } + + // Sugar Cane + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(4), ItemUtils.getSimpleStack(Items.reeds, 32) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 1000), }, + 30 * 20, + 30, + 0); + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(5), ItemUtils.getSimpleStack(Items.reeds, 32), + ItemUtils.getSimpleStack(ModItems.dustCalciumCarbonate, 2) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mThermalWater, 2000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 2000), }, + 10 * 20, + 30, + 0); + + // Sugar Beet + if (OreDictUtils.containsValidEntries("cropSugarbeet")) { + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(4), ItemUtils.getItemStackOfAmountFromOreDict("cropSugarbeet", 4), }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 1000), }, + 30 * 20, + 30, + 0); + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(5), ItemUtils.getItemStackOfAmountFromOreDict("cropSugarbeet", 4), + ItemUtils.getSimpleStack(ModItems.dustCalciumCarbonate, 2) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mThermalWater, 2000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 2000), }, + 10 * 20, + 30, + 0); + } + + // Produce Acetone, Butanol and Ethanol + GT_Values.RA.stdBuilder() + .itemInputs( + getBioChip(5), + ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownCelluloseFiber, 6), + ItemUtils.getSimpleStack(AgriculturalChem.mRedCelluloseFiber, 16)) + .fluidInputs(FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 48000)) + .fluidOutputs( + FluidUtils.getFluidStack(BioRecipes.mButanol, 18000), + FluidUtils.getFluidStack(BioRecipes.mAcetone, 9000), + FluidUtils.getFluidStack(BioRecipes.mEthanol, 3000)) + .duration(100 * SECONDS) + .eut(32) + .specialValue(1) + .noOptimize() + .addTo(chemicalPlantRecipes); + } + + private static void recipePropionicAcid() { + // C2H4 + CO + H2O = C3H6O2 + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { CI.getGreenCatalyst(0) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mEthylene, 1000), + FluidUtils.getFluidStack(BioRecipes.mCarbonMonoxide, 1000), + FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mPropionicAcid, 1000), }, + 10 * 20, + 60, + 1); + } + + private static void recipeEthanol() { + + GT_Values.RA.stdBuilder() + .itemInputs(BioRecipes.getBioChip(2)) + .fluidInputs(FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 1000)) + .fluidOutputs(FluidUtils.getFluidStack(BioRecipes.mEthanol, 100)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(distilleryRecipes); + } + + private static void recipeGoldenBrownCelluloseFiber() { + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownCelluloseFiber, 5)) + .fluidOutputs(Materials.Ammonia.getGas(500)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(fluidExtractionRecipes); + } + + private static void recipeRedCelluloseFiber() { + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mRedCelluloseFiber, 3)) + .itemOutputs(ItemUtils.getSimpleStack(ModItems.dustCalciumCarbonate, 5)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV / 2) + .addTo(extractorRecipes); + } + + private static void recipeSodiumHydroxide() { + // NaCl·H2O = NaOH + Cl + H + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(4) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mSalineWater, 1000), }, + new ItemStack[] { ItemUtils.getSimpleStack(AgriculturalChem.mSodiumHydroxide, 3) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mChlorine, 1000), + FluidUtils.getFluidStack(BioRecipes.mHydrogen, 1000), }, + 300 * 20, + 120, + 1); + + // Na + H2O = NaOH + H + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(5), ItemUtils.getItemStackOfAmountFromOreDict("dustSodium", 5) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 5000), }, + new ItemStack[] { ItemUtils.getSimpleStack(AgriculturalChem.mSodiumHydroxide, 15) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mHydrogen, 5000), }, + 60 * 20, + 60, + 1); + } + + private static void recipeSodiumCarbonate() { + + if (OreDictUtils.containsValidEntries("fuelCoke")) { + // Na2CO3 + Al2O3 =C= 2NaAlO2 + CO2 + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(18), ItemUtils.getItemStackOfAmountFromOreDict("fuelCoke", 1), + ItemUtils.getSimpleStack(AgriculturalChem.mSodiumCarbonate, 6), + ItemUtils.getSimpleStack(AgriculturalChem.mAluminiumPellet, 5) }, + new FluidStack[] {}, + new ItemStack[] { ItemUtils.getSimpleStack(AgriculturalChem.mSodiumAluminate, 8) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mCarbonDioxide, 1000), }, + 120 * 20, + 120, + 1); + } + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(18), ItemUtils.getItemStackOfAmountFromOreDict("dustCoal", 2), + ItemUtils.getSimpleStack(AgriculturalChem.mSodiumCarbonate, 6), + ItemUtils.getSimpleStack(AgriculturalChem.mAluminiumPellet, 5) }, + new FluidStack[] {}, + new ItemStack[] { ItemUtils.getSimpleStack(AgriculturalChem.mSodiumAluminate, 8) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mCarbonDioxide, 1000), }, + 180 * 20, + 120, + 1); + } + + private static void recipePelletMold() { + GregtechItemList.Pellet_Mold.set(ItemUtils.getSimpleStack(AgriculturalChem.mPelletMold, 1)); + GT_Values.RA.stdBuilder() + .itemInputs(ALLOY.TUMBAGA.getBlock(1)) + .itemOutputs(GregtechItemList.Pellet_Mold.get(1)) + .duration(7 * MINUTES + 30 * SECONDS) + .eut(TierEU.RECIPE_MV / 4 * 3) + .addTo(latheRecipes); + } + + private static void recipeAluminiumPellet() { + + // Ore Names, no prefix + AutoMap<String> aOreNames = new AutoMap<>(); + + aOreNames.put("Lazurite"); + aOreNames.put("Bauxite"); + aOreNames.put("Grossular"); + aOreNames.put("Pyrope"); + aOreNames.put("Sodalite"); + aOreNames.put("Spodumene"); + aOreNames.put("Ruby"); + aOreNames.put("Sapphire"); + aOreNames.put("GreenSapphire"); + + // Voltage + HashMap<String, Integer> aOreData1 = new HashMap<>(); + // Input Count + HashMap<String, Integer> aOreData2 = new HashMap<>(); + // Output Count + HashMap<String, Integer> aOreData3 = new HashMap<>(); + + aOreData1.put("Lazurite", 120); + aOreData1.put("Bauxite", 90); + aOreData1.put("Grossular", 90); + aOreData1.put("Pyrope", 90); + aOreData1.put("Sodalite", 90); + aOreData1.put("Spodumene", 90); + aOreData1.put("Ruby", 60); + aOreData1.put("Sapphire", 30); + aOreData1.put("GreenSapphire", 30); + aOreData2.put("Lazurite", 14); + aOreData2.put("Bauxite", 39); + aOreData2.put("Grossular", 20); + aOreData2.put("Pyrope", 20); + aOreData2.put("Sodalite", 11); + aOreData2.put("Spodumene", 10); + aOreData2.put("Ruby", 6); + aOreData2.put("Sapphire", 5); + aOreData2.put("GreenSapphire", 5); + aOreData3.put("Lazurite", 3); + aOreData3.put("Bauxite", 16); + aOreData3.put("Grossular", 2); + aOreData3.put("Pyrope", 2); + aOreData3.put("Sodalite", 3); + aOreData3.put("Spodumene", 1); + aOreData3.put("Ruby", 2); + aOreData3.put("Sapphire", 2); + aOreData3.put("GreenSapphire", 2); + + // Assemble all valid crushed ore types for making pellet mix + HashMap<String, ItemStack> aOreCache = new HashMap<>(); + for (String aOreName : aOreNames) { + String aTemp = aOreName; + aOreName = "crushedPurified" + aOreName; + if (ItemUtils.doesOreDictHaveEntryFor(aOreName)) { + aOreCache.put(aTemp, ItemUtils.getItemStackOfAmountFromOreDict(aOreName, 1)); + } + } + + for (String aOreName : aOreNames) { + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { CI.getNumberedBioCircuit(14), + ItemUtils.getSimpleStack(aOreCache.get(aOreName), aOreData2.get(aOreName)) }, + new FluidStack[] { FluidUtils.getSteam(2000 * aOreData2.get(aOreName)) }, + new ItemStack[] { ItemUtils.getSimpleStack( + AgriculturalChem.mCleanAluminiumMix, + (int) (Math.ceil(aOreData3.get(aOreName) * 1.4))) }, + new FluidStack[] { FluidUtils + .getFluidStack(AgriculturalChem.RedMud, 100 * (int) (Math.ceil(aOreData3.get(aOreName) * 1.4))) }, + 20 * 60, + aOreData1.get(aOreName), + aOreName.equals("Bauxite") ? 2 : 1); + } + GT_Values.RA.stdBuilder() + .itemInputs( + ItemUtils.getSimpleStack(AgriculturalChem.mCleanAluminiumMix, 3), + ItemUtils.getSimpleStack(AgriculturalChem.mPelletMold, 0)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mAluminiumPellet, 4)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(extruderRecipes); + } + + private static void recipeAlumina() { + // 2NaAlO2 + 2NaOH + 2CO2 = Al2O3 + 2Na2CO3 + H2O + GT_Values.RA.stdBuilder() + .itemInputs( + ItemUtils.getSimpleStack(AgriculturalChem.mSodiumAluminate, 8), + ItemUtils.getSimpleStack(AgriculturalChem.mSodiumHydroxide, 6)) + .itemOutputs( + ItemUtils.getSimpleStack(AgriculturalChem.mAlumina, 5), + ItemUtils.getSimpleStack(AgriculturalChem.mSodiumCarbonate, 12)) + .fluidInputs(Materials.CarbonDioxide.getGas(2000L)) + .duration(40 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 1200) + .addTo(blastFurnaceRecipes); + } + + private static void recipeAluminium() { + // 2Al2O3 + 3C = 4Al + 3CO2 + GT_Values.RA.stdBuilder() + .itemInputs( + ItemUtils.getSimpleStack(AgriculturalChem.mAlumina, 10), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Carbon, 3L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Aluminium, 4L)) + .fluidOutputs(Materials.CarbonDioxide.getGas(3000L)) + .duration(2 * MINUTES) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 1600) + .addTo(blastFurnaceRecipes); + } + + private static void recipeLithiumChloride() { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.RockSalt, 8), + ItemUtils.getSimpleStack(AgriculturalChem.mLithiumChloride, 10)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lithium, 2), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Lithium, 3), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Lithium, 3), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Lithium, 5), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Potassium, 2), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Potassium, 5)) + .outputChances(7500, 8000, 8500, 9000, 7500, 8500) + .fluidInputs(FluidUtils.getFluidStack(BioRecipes.mAir, 4000)) + .fluidOutputs(FluidUtils.getFluidStack(BioRecipes.mChlorine, 500)) + .duration(1 * MINUTES + 30 * SECONDS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(multiblockChemicalReactorRecipes); + if (OreDictUtils.containsValidEntries("dustPotash")) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Potash, 10), + ItemUtils.getSimpleStack(AgriculturalChem.mLithiumChloride, 16)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lithium, 3), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Lithium, 5), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Lithium, 5), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Lithium, 7), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Ash, 2), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Ash, 2)) + .outputChances(7500, 8000, 8500, 9000, 9000, 9000) + .fluidInputs(FluidUtils.getFluidStack(BioRecipes.mThermalWater, 2000)) + .fluidOutputs(FluidUtils.getFluidStack(BioRecipes.mChlorine, 250)) + .duration(1 * MINUTES) + .eut(TierEU.RECIPE_MV) + .addTo(multiblockChemicalReactorRecipes); + } + } + + private static void recipeSulfuricAcid() { + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(7), ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 10), + ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 6) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 5000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mSulfuricAcid, 5000), }, + 50 * 20, + 60, + 1); + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(7), ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownCelluloseFiber, 2), + ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 10) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 5000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mSulfuricAcid, 5000), }, + 6 * 20, + 180, + 3); + } + + private static void recipeUrea() { + + // 2NH3 + CO2 = CH4N2O + H2O + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(9), }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mAmmonia, 600), + FluidUtils.getFluidStack(BioRecipes.mCarbonDioxide, 300), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mUrea, 300), + FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 300), }, + 5 * 20, + 30, + 1); + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(9), }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mUrea, 200), + FluidUtils.getFluidStack(BioRecipes.mFormaldehyde, 200), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mLiquidResin, 200) }, + 5 * 20, + 30, + 1); + } + + private static void recipeRawBioResin() { + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(3), ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 5), + ItemUtils.getSimpleStack(Blocks.dirt, 1) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 100), }, + new ItemStack[] { ItemUtils.getSimpleStack(AgriculturalChem.mRawBioResin, 1), }, + new FluidStack[] {}, + 1 * 20, + 30, + 1); + } + + private static void recipeLiquidResin() { + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(3), ItemUtils.getSimpleStack(AgriculturalChem.mRawBioResin, 1) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mEthanol, 200), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mLiquidResin, 500), }, + 5 * 20, + 30, + 1); + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(3), ItemUtils.getSimpleStack(AgriculturalChem.mCellulosePulp, 8) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mLiquidResin, 144), }, + new ItemStack[] { ItemUtils.getSimpleStack(Ic2Items.resin, 32) }, + new FluidStack[] {}, + 60 * 20, + 30, + 1); + } + + private static void recipeCompost() { + ItemStack aFert; + if (Forestry.isModLoaded()) { + aFert = ItemUtils.getSimpleStack(AgriculturalChem.aFertForestry, 32); + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(11), ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 16), + ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 8) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mUrea, 200), }, + new ItemStack[] { aFert }, + new FluidStack[] {}, + 30 * 20, + 60, + 1); + } + + aFert = ItemUtils.getSimpleStack(AgriculturalChem.aFertIC2, 32); + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(12), ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 16), + ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 8) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mUrea, 200), }, + new ItemStack[] { aFert }, + new FluidStack[] {}, + 30 * 20, + 60, + 1); + } + + private static void recipeMethane() { + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(12), ItemUtils.getSimpleStack(AgriculturalChem.mAlgaeBiosmass, 10) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 500), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mMethane, 500), }, + 5 * 20, + 64, + 1); + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(13), ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 8), + ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownCelluloseFiber, 6), + ItemUtils.getSimpleStack(AgriculturalChem.mRedCelluloseFiber, 4) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mMethane, 2000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mEthylene, 2000), }, + 10 * 20, + 60, + 1); + } + + private static void recipeBenzene() { + + // 6CH4 = C6H6 + 18H + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(19), CI.getGreenCatalyst(0), }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mMethane, 6000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mBenzene, 1000), Materials.Hydrogen.getGas(18000) }, + 8 * 20, + 120, + 2); + } + + private static void recipeStyrene() { + + // C8H10 = C8H8 + 2H + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(20), CI.getGreenCatalyst(0), }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mEthylbenzene, 100), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mStyrene, 100), Materials.Hydrogen.getGas(200) }, + 16 * 20, + 480, + 2); + } + + private static void recipeBioChip() { + GT_ModHandler.addShapelessCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 0L), + 0, + new Object[] { OrePrefixes.circuit.get(Materials.Primitive) }); + + long bits = 0; + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 1L, new Object[0]), + bits, + new Object[] { "d ", " P ", " ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 2L, new Object[0]), + bits, + new Object[] { " d ", " P ", " ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 3L, new Object[0]), + bits, + new Object[] { " d", " P ", " ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 4L, new Object[0]), + bits, + new Object[] { " ", " Pd", " ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 5L, new Object[0]), + bits, + new Object[] { " ", " P ", " d", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 6L, new Object[0]), + bits, + new Object[] { " ", " P ", " d ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 7L, new Object[0]), + bits, + new Object[] { " ", " P ", "d ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 8L, new Object[0]), + bits, + new Object[] { " ", "dP ", " ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 9L, new Object[0]), + bits, + new Object[] { "P d", " ", " ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 10L, new Object[0]), + bits, + new Object[] { "P ", " d", " ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 11L, new Object[0]), + bits, + new Object[] { "P ", " ", " d", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 12L, new Object[0]), + bits, + new Object[] { "P ", " ", " d ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 13L, new Object[0]), + bits, + new Object[] { " P", " ", " d", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 14L, new Object[0]), + bits, + new Object[] { " P", " ", " d ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 15L, new Object[0]), + bits, + new Object[] { " P", " ", "d ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 16L, new Object[0]), + bits, + new Object[] { " P", "d ", " ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 17L, new Object[0]), + bits, + new Object[] { " ", " ", "d P", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 18L, new Object[0]), + bits, + new Object[] { " ", "d ", " P", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 19L, new Object[0]), + bits, + new Object[] { "d ", " ", " P", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 20L, new Object[0]), + bits, + new Object[] { " d ", " ", " P", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 21L, new Object[0]), + bits, + new Object[] { "d ", " ", "P ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 22L, new Object[0]), + bits, + new Object[] { " d ", " ", "P ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 23L, new Object[0]), + bits, + new Object[] { " d", " ", "P ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + addCraftingRecipe( + GregtechItemList.Circuit_BioRecipeSelector.getWithDamage(1L, 24L, new Object[0]), + bits, + new Object[] { " ", " d", "P ", 'P', + GregtechItemList.Circuit_BioRecipeSelector.getWildcard(1L, new Object[0]) }); + } + + public static boolean addCraftingRecipe(ItemStack aResult, long aBitMask, Object[] aRecipe) { + Method mAddRecipe = ReflectionUtils.getMethod( + GT_ModHandler.class, + "addCraftingRecipe", + new Class[] { ItemStack.class, Enchantment[].class, int[].class, boolean.class, boolean.class, + boolean.class, boolean.class, boolean.class, boolean.class, boolean.class, boolean.class, boolean.class, + boolean.class, boolean.class, boolean.class, boolean.class, Object[].class }); + boolean didInvoke = false; + if (mAddRecipe != null) { + try { + didInvoke = (boolean) mAddRecipe.invoke( + null, + aResult, + new Enchantment[] {}, + new int[] {}, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + true, + aRecipe); + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + return didInvoke; + } +} diff --git a/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java new file mode 100644 index 0000000000..0c3d7d2867 --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/Core_Agrichem.java @@ -0,0 +1,56 @@ +package gtPlusPlus.plugin.agrichem; + +import gtPlusPlus.api.interfaces.IPlugin; +import gtPlusPlus.plugin.agrichem.block.AgrichemFluids; +import gtPlusPlus.plugin.manager.Core_Manager; + +// Called by Core_Manager#veryEarlyInit +@SuppressWarnings("unused") +public class Core_Agrichem implements IPlugin { + + static final Core_Agrichem mInstance; + + static { + mInstance = new Core_Agrichem(); + Core_Manager.registerPlugin(mInstance); + mInstance.log("Preparing " + mInstance.getPluginName() + " for use."); + } + + @Override + public boolean preInit() { + AgrichemFluids.init(); + return true; + } + + @Override + public boolean init() { + mInstance.log("Setting Items"); + return true; + } + + @Override + public boolean postInit() { + mInstance.log("Generating Recipes"); + return true; + } + + @Override + public boolean serverStart() { + return true; + } + + @Override + public boolean serverStop() { + return true; + } + + @Override + public String getPluginName() { + return "GT++ Agrichemistry Module"; + } + + @Override + public String getPluginAbbreviation() { + return "FARM"; + } +} diff --git a/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/IAlgalItem.java b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/IAlgalItem.java new file mode 100644 index 0000000000..8ce137a323 --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/IAlgalItem.java @@ -0,0 +1,12 @@ +package gtPlusPlus.plugin.agrichem; + +import net.minecraft.item.ItemStack; + +import gtPlusPlus.plugin.agrichem.logic.AlgaeGeneticData; + +public interface IAlgalItem { + + AlgaeDefinition getAlgaeType(ItemStack aStack); + + AlgaeGeneticData getSpeciesData(ItemStack aStack); +} diff --git a/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/block/AgrichemFluids.java b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/block/AgrichemFluids.java new file mode 100644 index 0000000000..bd72654f0a --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/block/AgrichemFluids.java @@ -0,0 +1,77 @@ +package gtPlusPlus.plugin.agrichem.block; + +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; + +import gtPlusPlus.core.util.minecraft.FluidUtils; + +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 + */ + + public static Fluid mAceticAcid; + public static Fluid mPropionicAcid; + public static Fluid mFermentationBase; + public static Fluid mUrea; + public static Fluid mLiquidResin; + public static Fluid mAcetone; + public static Fluid mButanol; + + 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"); + } + + if (!FluidRegistry.isFluidRegistered("acetone")) { + mAcetone = FluidUtils + .generateFluidNoPrefix("acetone", "Acetone", 200, new short[] { 59, 58, 56, 100 }, true); + } else { + mAcetone = FluidRegistry.getFluid("acetone"); + } + if (!FluidRegistry.isFluidRegistered("butanol")) { + mButanol = FluidUtils + .generateFluidNoPrefix("butanol", "Butanol", 200, new short[] { 159, 58, 56, 100 }, true); + } else { + mButanol = FluidRegistry.getFluid("butanol"); + } + } +} diff --git a/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java new file mode 100644 index 0000000000..8a6d189898 --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemAgrichemBase.java @@ -0,0 +1,268 @@ +package gtPlusPlus.plugin.agrichem.item.algae; + +import static gregtech.api.enums.Mods.GTPlusPlus; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.util.List; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +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.EnumChatFormatting; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; +import net.minecraftforge.oredict.OreDictionary; + +import cpw.mods.fml.common.registry.GameRegistry; +import gtPlusPlus.core.item.chemistry.general.ItemGenericChemBase; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.OreDictUtils; +import gtPlusPlus.core.util.reflect.ReflectionUtils; + +public class ItemAgrichemBase extends Item { + + protected final IIcon base[]; + + /* + * 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 22 - Pellet Mold 23 - Clean Aluminium Mix 24 - Pinecone 25 - Crushed + * Pine + */ + + public ItemAgrichemBase() { + this.setHasSubtypes(true); + this.setNoRepair(); + this.setMaxStackSize(64); + this.setMaxDamage(0); + base = new IIcon[26]; + 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 EnumRarity getRarity(ItemStack p_77613_1_) { + return EnumRarity.common; + } + + @Override + public boolean requiresMultipleRenderPasses() { + return false; + } + + private static boolean mHasCheckedForSodiumHydroxide = false; + private static boolean mShowSodiumHydroxide = true; + + private static boolean checkSodiumHydroxide() { + if (mHasCheckedForSodiumHydroxide) { + return mShowSodiumHydroxide; + } else { + if (OreDictUtils.containsValidEntries("dustSodiumHydroxide_GT5U") + || OreDictUtils.containsValidEntries("dustSodiumHydroxide")) { + List<ItemStack> 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 < base.length; i++) { + if (i == 19) { + // Only show if it doesn't exist. + if (checkSodiumHydroxide()) { + aList.add(ItemUtils.simpleMetaStack(aItem, i, 1)); + } + } else { + aList.add(ItemUtils.simpleMetaStack(aItem, i, 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 getItemEnchantability() { + return 0; + } + + @Override + public int getItemEnchantability(ItemStack stack) { + return 0; + } + + @Override + public void registerIcons(final IIconRegister u) { + for (int i = 0; i < this.base.length; i++) { + String aPath = GTPlusPlus.ID + ":" + "bioscience/MetaItem1/" + i; + this.base[i] = u.registerIcon(aPath); + } + } + + private boolean isTextureValid(String aPath) { + if (aPath == null) { + return false; + } else if (aPath.indexOf(92) == -1) { + Constructor aTextureAtlasSprite = ReflectionUtils.getConstructor(TextureAtlasSprite.class, String.class); + if (aTextureAtlasSprite != null) { + try { + TextureAtlasSprite aTestAtlas = (TextureAtlasSprite) aTextureAtlasSprite.newInstance(aPath); + if (aTestAtlas != null) { + return true; + } + } catch (InstantiationException | IllegalAccessException | IllegalArgumentException + | InvocationTargetException e) {} + } + } + return false; + } + + @Override + public IIcon getIconFromDamageForRenderPass(final int damage, final int pass) { + return this.base[damage]; + } + + @Override + public IIcon getIconFromDamage(int damage) { + return this.base[damage]; + } + + @Override + public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining) { + return this.base[stack.getItemDamage()]; + } + + @Override + public IIcon getIcon(ItemStack stack, int pass) { + return this.base[stack.getItemDamage()]; + } + + @Override + public String getUnlocalizedName(ItemStack stack) { + return super.getUnlocalizedName() + "." + stack.getItemDamage(); + } + + @Override + public double getDurabilityForDisplay(ItemStack aStack) { + if (ItemUtils.isCatalyst(aStack)) { + if (aStack.getTagCompound() == null || aStack.getTagCompound() + .hasNoTags()) { + createCatalystNBT(aStack); + } + double currentDamage = getCatalystDamage(aStack); + return currentDamage / getCatalystMaxDamage(aStack); + } else { + return 1D; + } + } + + @SuppressWarnings("unchecked") + @Override + public void addInformation(ItemStack aStack, EntityPlayer player, List list, boolean bool) { + boolean aHasSpecialTooltips = false; + int aMaxDamage = 0; + int aDamageSegment = 0; + int aDam = 0; + EnumChatFormatting durability = EnumChatFormatting.GRAY; + if (ItemUtils.isCatalyst(aStack)) { + list.add(EnumChatFormatting.GRAY + "Active Reaction Agent"); + aMaxDamage = getCatalystMaxDamage(aStack); + aDamageSegment = aMaxDamage / 5; + aDam = aMaxDamage - getCatalystDamage(aStack); + aHasSpecialTooltips = true; + } + if (aHasSpecialTooltips) { + if (aDam > aDamageSegment * 3) { + durability = EnumChatFormatting.GREEN; + } else if (aDam > aDamageSegment * 2) { + durability = EnumChatFormatting.YELLOW; + } else if (aDam > aDamageSegment) { + durability = EnumChatFormatting.GOLD; + } else if (aDam >= 0) { + durability = EnumChatFormatting.RED; + } + list.add(durability + "" + (aDam) + EnumChatFormatting.GRAY + " / " + aMaxDamage); + } + super.addInformation(aStack, player, list, bool); + } + + @Override + public boolean showDurabilityBar(ItemStack aStack) { + if (ItemUtils.isCatalyst(aStack)) { + int aDam = getCatalystDamage(aStack); + return aDam > 0; + } + return false; + } + + public static boolean createCatalystNBT(ItemStack rStack) { + return ItemGenericChemBase.createCatalystNBT(rStack); + } + + public static int getCatalystDamage(ItemStack aStack) { + return ItemGenericChemBase.getCatalystDamage(aStack); + } + + public static int getCatalystMaxDamage(ItemStack aStack) { + return ItemGenericChemBase.getCatalystMaxDamage(aStack); + } + + public static void setCatalystDamage(ItemStack aStack, int aAmount) { + ItemGenericChemBase.setCatalystDamage(aStack, aAmount); + } + + public static int getMaxCatalystDurability(ItemStack aStack) { + return ItemGenericChemBase.getMaxCatalystDurability(aStack); + } +} diff --git a/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemAlgaeBase.java b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemAlgaeBase.java new file mode 100644 index 0000000000..f34348a3af --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/item/algae/ItemAlgaeBase.java @@ -0,0 +1,225 @@ +package gtPlusPlus.plugin.agrichem.item.algae; + +import static gregtech.api.enums.Mods.GTPlusPlus; + +import java.util.List; + +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; + +import cpw.mods.fml.common.registry.GameRegistry; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.plugin.agrichem.AlgaeDefinition; +import gtPlusPlus.plugin.agrichem.IAlgalItem; +import gtPlusPlus.plugin.agrichem.logic.AlgaeGeneticData; + +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 < AlgaeDefinition.values().length; i++) { + aList.add(ItemUtils.simpleMetaStack(aItem, i, 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 boolean showDurabilityBar(ItemStack stack) { + return false; + } + + @Override + public int getItemEnchantability() { + return 0; + } + + @Override + public int getItemEnchantability(ItemStack stack) { + return 0; + } + + @Override + public int getColorFromItemStack(ItemStack aStack, int aMeta) { + return AlgaeDefinition.getByIndex(aStack.getItemDamage()).mColour; + } + + @Override + public IIcon getIconFromDamageForRenderPass(final int damage, final int pass) { + if (pass == 0) { + return this.base; + } + return this.overlay; + } + + @Override + public void registerIcons(final IIconRegister i) { + this.base = i.registerIcon(GTPlusPlus.ID + ":" + "bioscience/BasicAlgae"); + this.overlay = i.registerIcon(GTPlusPlus.ID + ":" + "bioscience/BasicAlgae_Overlay"); + } + + public static ItemStack initNBT(ItemStack aFreshAlgae) { + NBTTagCompound aNewTag = new NBTTagCompound(); + ItemAlgaeBase aItem; + if (aFreshAlgae.getItem() instanceof ItemAlgaeBase) { + aItem = (ItemAlgaeBase) aFreshAlgae.getItem(); + if (!aFreshAlgae.hasTagCompound()) { + AlgaeGeneticData y = aItem.getSpeciesData(aFreshAlgae); + aNewTag = y.writeToNBT(); + aFreshAlgae.setTagCompound(aNewTag); + } else { + aNewTag = aFreshAlgae.getTagCompound(); + } + } + return aFreshAlgae; + } + + @Override + public AlgaeDefinition getAlgaeType(ItemStack aStack) { + return AlgaeDefinition.getByIndex(aStack != null ? aStack.getItemDamage() : 3); + } + + @Override + public AlgaeGeneticData getSpeciesData(ItemStack aStack) { + NBTTagCompound aTag; + if (!aStack.hasTagCompound() || aStack.getTagCompound() + .hasNoTags()) { + aTag = new NBTTagCompound(); + AlgaeGeneticData aGenes; + if (aStack.getItemDamage() < 3 || aStack.getItemDamage() > 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/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/logic/AlgaeGeneticData.java b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/logic/AlgaeGeneticData.java new file mode 100644 index 0000000000..6b7b72aa71 --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/logic/AlgaeGeneticData.java @@ -0,0 +1,129 @@ +package gtPlusPlus.plugin.agrichem.logic; + +import net.minecraft.nbt.NBTTagCompound; + +import gtPlusPlus.api.objects.data.AutoMap; + +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<AlgaeGrowthRequirement> 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<AlgaeGrowthRequirement> 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<AlgaeGrowthRequirement> 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/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/logic/AlgaeGrowthRequirement.java b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/logic/AlgaeGrowthRequirement.java new file mode 100644 index 0000000000..07b89e5b5e --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/agrichem/logic/AlgaeGrowthRequirement.java @@ -0,0 +1,4 @@ +package gtPlusPlus.plugin.agrichem.logic; + +public class AlgaeGrowthRequirement { +} diff --git a/gtpp/src/main/java/gtPlusPlus/plugin/fixes/interfaces/IBugFix.java b/gtpp/src/main/java/gtPlusPlus/plugin/fixes/interfaces/IBugFix.java new file mode 100644 index 0000000000..b35ad2c063 --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/fixes/interfaces/IBugFix.java @@ -0,0 +1,6 @@ +package gtPlusPlus.plugin.fixes.interfaces; + +public interface IBugFix { + + boolean isFixValid(); +} diff --git a/gtpp/src/main/java/gtPlusPlus/plugin/fixes/vanilla/Core_VanillaFixes.java b/gtpp/src/main/java/gtPlusPlus/plugin/fixes/vanilla/Core_VanillaFixes.java new file mode 100644 index 0000000000..cc181756c0 --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/fixes/vanilla/Core_VanillaFixes.java @@ -0,0 +1,101 @@ +package gtPlusPlus.plugin.fixes.vanilla; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; + +import gtPlusPlus.api.interfaces.IPlugin; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.plugin.manager.Core_Manager; + +// Called by Core_Manager#veryEarlyInit +@SuppressWarnings("unused") +public class Core_VanillaFixes implements IPlugin { + + static final Core_VanillaFixes mInstance; + static final VanillaBedHeightFix mBedFixInstance; + static final VanillaBackgroundMusicFix mMusicFixInstance; + + static { + mInstance = new Core_VanillaFixes(); + mBedFixInstance = new VanillaBedHeightFix(mInstance); + mMusicFixInstance = new VanillaBackgroundMusicFix(mInstance); + mInstance.log("Preparing " + mInstance.getPluginName() + " for use."); + } + + Core_VanillaFixes() { + Core_Manager.registerPlugin(this); + } + + @Override + public boolean preInit() { + return fixVanillaOD(); + } + + @Override + public boolean init() { + return true; + } + + @Override + public boolean postInit() { + return true; + } + + @Override + public boolean serverStart() { + mMusicFixInstance.manage(); + return true; + } + + @Override + public boolean serverStop() { + return true; + } + + @Override + public String getPluginName() { + return "GT++ Vanilla Fixes Module"; + } + + @Override + public String getPluginAbbreviation() { + return "VFIX"; + } + + private boolean fixVanillaOD() { + registerToOreDict(ItemUtils.getSimpleStack(Items.blaze_rod), "rodBlaze"); + registerToOreDict(ItemUtils.getSimpleStack(Items.nether_wart), "cropNetherWart"); + registerToOreDict(ItemUtils.getSimpleStack(Items.reeds), "sugarcane"); + registerToOreDict(ItemUtils.getSimpleStack(Items.paper), "paper"); + registerToOreDict(ItemUtils.getSimpleStack(Items.ender_pearl), "enderpearl"); + registerToOreDict(ItemUtils.getSimpleStack(Items.bone), "bone"); + registerToOreDict(ItemUtils.getSimpleStack(Items.gunpowder), "gunpowder"); + registerToOreDict(ItemUtils.getSimpleStack(Items.string), "string"); + registerToOreDict(ItemUtils.getSimpleStack(Items.nether_star), "netherStar"); + registerToOreDict(ItemUtils.getSimpleStack(Items.leather), "leather"); + registerToOreDict(ItemUtils.getSimpleStack(Items.feather), "feather"); + registerToOreDict(ItemUtils.getSimpleStack(Items.egg), "egg"); + registerToOreDict(ItemUtils.getSimpleStack(Blocks.end_stone), "endstone"); + registerToOreDict(ItemUtils.getSimpleStack(Blocks.vine), "vine"); + registerToOreDict(ItemUtils.getSimpleStack(Blocks.cactus), "blockCactus"); + registerToOreDict(ItemUtils.getSimpleStack(Blocks.grass), "grass"); + registerToOreDict(ItemUtils.getSimpleStack(Blocks.obsidian), "obsidian"); + registerToOreDict(ItemUtils.getSimpleStack(Blocks.crafting_table), "workbench"); + return true; + } + + private void registerToOreDict(ItemStack aStack, String aString) { + if (aStack.getItem() == Items.blaze_rod) { + mInstance + .log("Registering " + aStack.getDisplayName() + " to OreDictionary under the tag '" + aString + "'."); + } else { + mInstance.log( + "Registering " + aStack.getDisplayName() + + " to OreDictionary under the tag '" + + aString + + "'. (Added to Forge in 1.8.9)"); + } + ItemUtils.addItemToOreDictionary(aStack, aString); + } +} diff --git a/gtpp/src/main/java/gtPlusPlus/plugin/fixes/vanilla/VanillaBackgroundMusicFix.java b/gtpp/src/main/java/gtPlusPlus/plugin/fixes/vanilla/VanillaBackgroundMusicFix.java new file mode 100644 index 0000000000..22ae6f29c6 --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/fixes/vanilla/VanillaBackgroundMusicFix.java @@ -0,0 +1,64 @@ +package gtPlusPlus.plugin.fixes.vanilla; + +import java.util.Timer; +import java.util.TimerTask; + +import gtPlusPlus.api.interfaces.IPlugin; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.plugin.fixes.interfaces.IBugFix; +import gtPlusPlus.plugin.fixes.vanilla.music.MusicTocker; +import gtPlusPlus.preloader.CORE_Preloader; + +public class VanillaBackgroundMusicFix implements IBugFix { + + private final IPlugin mParent; + private final boolean enabled; + private MusicTocker mFixInstance; + + public VanillaBackgroundMusicFix(IPlugin minstance) { + mParent = minstance; + if (CORE_Preloader.enableWatchdogBGM > 0 && Utils.isClient()) { + mParent.log("[BGM] Registering BGM delay Fix."); + enabled = true; + mFixInstance = new MusicTocker(mParent); + } else if (CORE_Preloader.enableWatchdogBGM > 0 && Utils.isServer()) { + mParent.log("[BGM] Tried registering BGM delay Fix on Server, disabling."); + enabled = false; + } else { + mParent.log("[BGM] Not registering BGM delay Fix."); + enabled = false; + } + } + + @Override + public boolean isFixValid() { + return enabled; + } + + public void manage() { + if (CORE_Preloader.enableWatchdogBGM > 0 && Utils.isClient()) { + TimerTask task = new ManageTask(this.mFixInstance); + Timer timer = new Timer("BGM-WatchDog"); + long delay = 1000 * 60; + timer.scheduleAtFixedRate(task, delay, 5000); + } + } + + private static class ManageTask extends TimerTask { + + private final MusicTocker A; + + public ManageTask(MusicTocker a) { + A = a; + } + + @Override + public void run() { + if (CORE_Preloader.enableWatchdogBGM > 0 && Utils.isClient()) { + if (!A.mVanillaManager) { + A.run(); + } + } + } + } +} diff --git a/gtpp/src/main/java/gtPlusPlus/plugin/fixes/vanilla/VanillaBedHeightFix.java b/gtpp/src/main/java/gtPlusPlus/plugin/fixes/vanilla/VanillaBedHeightFix.java new file mode 100644 index 0000000000..60ab048ca3 --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/fixes/vanilla/VanillaBedHeightFix.java @@ -0,0 +1,85 @@ +package gtPlusPlus.plugin.fixes.vanilla; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.event.entity.player.PlayerSleepInBedEvent; + +import cpw.mods.fml.common.eventhandler.EventPriority; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import gtPlusPlus.api.interfaces.IPlugin; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.reflect.ReflectionUtils; +import gtPlusPlus.plugin.fixes.interfaces.IBugFix; +import gtPlusPlus.preloader.CORE_Preloader; + +public class VanillaBedHeightFix implements IBugFix { + + private final Method mSleepInBedAt; + private final IPlugin mParent; + + public VanillaBedHeightFix(IPlugin minstance) { + mParent = minstance; + Method m; + if (!CORE_Preloader.DEV_ENVIRONMENT) { + m = ReflectionUtils.getMethod(EntityPlayer.class, "func_71018_a", int.class, int.class, int.class); + } else { + m = ReflectionUtils.getMethod( + net.minecraft.entity.player.EntityPlayer.class, + "sleepInBedAt", + int.class, + int.class, + int.class); + } + if (m != null) { + mSleepInBedAt = m; + mParent.log("Registering Bed Height Fix."); + Utils.registerEvent(this); + } else { + mSleepInBedAt = null; + } + } + + @Override + public boolean isFixValid() { + return mSleepInBedAt != null; + } + + /** + * Fix created by deNULL - + * https://github.com/deNULL/BugPatch/blob/master/src/main/java/ru/denull/BugPatch/mod/ClientEvents.java#L45 + * + * @param evt - The event where a player sleeps + */ + @SubscribeEvent(priority = EventPriority.HIGHEST) + public void playerSleepInBed(PlayerSleepInBedEvent evt) { + Logger.WARNING("Sleep Event Detected. Player is sleeping at Y: " + evt.y); + if (evt.y <= 0 && isFixValid()) { + int correctY = 256 + evt.y; + if (correctY <= 0) { + Logger.WARNING( + "You're trying to sleep at y=" + evt.y + + ", which is impossibly low. However, fixed y value is " + + correctY + + ", which is still below 0. Falling back to default behavior."); + } else { + Logger.WARNING( + "You're trying to sleep at y=" + evt.y + + ". This is probably caused by overflow, stopping original event; retrying with y=" + + correctY + + "."); + evt.result = EntityPlayer.EnumStatus.OTHER_PROBLEM; + try { + mSleepInBedAt.invoke(evt.entityPlayer, evt.x, correctY, evt.z); + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { + Logger.WARNING("Encountered an error trying to sleep."); + } + } + } else if (!isFixValid()) { + Logger.WARNING( + "Method sleepInBedAt was not found in EntityPlayer (wrong MC and/or Forge version?), unable to fix"); + } + } +} diff --git a/gtpp/src/main/java/gtPlusPlus/plugin/fixes/vanilla/music/MusicTocker.java b/gtpp/src/main/java/gtPlusPlus/plugin/fixes/vanilla/music/MusicTocker.java new file mode 100644 index 0000000000..c669f93f62 --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/fixes/vanilla/music/MusicTocker.java @@ -0,0 +1,131 @@ +package gtPlusPlus.plugin.fixes.vanilla.music; + +import java.lang.reflect.Field; +import java.util.Random; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.audio.ISound; +import net.minecraft.client.audio.MusicTicker; +import net.minecraft.client.audio.PositionedSoundRecord; +import net.minecraft.util.MathHelper; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.objects.XSTR; +import gtPlusPlus.api.interfaces.IPlugin; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.core.util.reflect.ReflectionUtils; +import gtPlusPlus.preloader.CORE_Preloader; + +@SideOnly(Side.CLIENT) +public class MusicTocker extends MusicTicker implements Runnable { + + private final Random mRandom = new XSTR(); + private final Minecraft mMinecraft; + private final IPlugin mPlugin; + private ISound mSound; + private int mTimeUntilNextTrack = 100; + + public boolean mVanillaManager = false; + + public MusicTocker(IPlugin aPlugin) { + super(Minecraft.getMinecraft()); + mPlugin = aPlugin; + mMinecraft = Minecraft.getMinecraft(); + mPlugin.log("[BGM] Created BGM Watchdog with a delay of " + getDelay() + " ticks."); + inject(); + } + + private static int getDelay() { + return CORE_Preloader.enableWatchdogBGM; + } + + private boolean inject() { + mPlugin.log("[BGM] Inject new Watchdog into Minecraft instance."); + ReflectionUtils.setField(Minecraft.getMinecraft(), "mcMusicTicker", this); + mPlugin.log("[BGM] Verifying..."); + Field f = ReflectionUtils.getField(Minecraft.class, "mcMusicTicker"); + try { + Object m = f.get(mMinecraft); + if (m != null) { + if (m instanceof MusicTocker || m.getClass() + .isAssignableFrom(getClass())) { + mPlugin.log("[BGM] Success."); + return true; + } else if (m instanceof MusicTicker || m.getClass() + .isAssignableFrom(MusicTicker.class)) { + mPlugin.log("[BGM] Found Vanilla MusicTicker, but may be instance of MusicTocker."); + return true; + } + } + } catch (IllegalArgumentException | IllegalAccessException e) {} + + mPlugin.log("[BGM] Failed."); + return false; + } + + private void updateInternalNumber() { + if (ReflectionUtils.doesFieldExist(getClass(), "field_147676_d")) { + ReflectionUtils.setField(this, "field_147676_d", mTimeUntilNextTrack); + } + } + + private void updateInternalSound(ISound aSound) { + if (ReflectionUtils.doesFieldExist(getClass(), "field_147678_c")) { + ReflectionUtils.setField(this, "field_147678_c", aSound); + } + } + + /** + * Updates the JList with a new model. + */ + @Override + public void update() { + run(); + mVanillaManager = true; + } + + @Override + public void run() { + MusicType musictype = this.mMinecraft.func_147109_W(); + + if (this.mSound != null) { + if (!musictype.getMusicTickerLocation() + .equals(this.mSound.getPositionedSoundLocation())) { + this.mMinecraft.getSoundHandler() + .stopSound(this.mSound); + this.mTimeUntilNextTrack = MathHelper.getRandomIntegerInRange(this.mRandom, 0, getDelay() / 2); + updateInternalNumber(); + Logger.INFO("[BGM] Adjusted BGM delay 1"); + } + if (!this.mMinecraft.getSoundHandler() + .isSoundPlaying(this.mSound)) { + this.mSound = null; + updateInternalSound(null); + this.mTimeUntilNextTrack = Math.min( + MathHelper.getRandomIntegerInRange(this.mRandom, getDelay(), getDelay() * 2), + this.mTimeUntilNextTrack); + updateInternalNumber(); + Logger.INFO("[BGM] Adjusted BGM delay 2"); + } + } else if (this.mSound == null && this.mTimeUntilNextTrack-- <= 0) { + this.mSound = PositionedSoundRecord.func_147673_a(musictype.getMusicTickerLocation()); + updateInternalSound(mSound); + this.mMinecraft.getSoundHandler() + .playSound(this.mSound); + this.mTimeUntilNextTrack = getDelay(); + updateInternalNumber(); + Logger.INFO("[BGM] Adjusted BGM 3"); + } + + /* + * try { // Get Value stored in underlying object. Integer aRealDelay = (Integer) + * ReflectionUtils.getField(getClass(), "field_147676_d").get(this); if (aRealDelay == null) { return; } else { + * if (aRealDelay > getDelay() || aRealDelay <= 0) { this.mTimeUntilNextTrack = getDelay(); + * updateInternalNumber(); } else { this.mTimeUntilNextTrack -= 5 * 20; updateInternalNumber(); } aRealDelay = + * (Integer) ReflectionUtils.getField(getClass(), "field_147676_d").get(this); + * Logger.INFO("[BGM] Adjusted BGM - "+aRealDelay); } } catch (IllegalArgumentException | IllegalAccessException + * e) { } + */ + } +} diff --git a/gtpp/src/main/java/gtPlusPlus/plugin/manager/Core_Manager.java b/gtpp/src/main/java/gtPlusPlus/plugin/manager/Core_Manager.java new file mode 100644 index 0000000000..be1dafd231 --- /dev/null +++ b/gtpp/src/main/java/gtPlusPlus/plugin/manager/Core_Manager.java @@ -0,0 +1,94 @@ +package gtPlusPlus.plugin.manager; + +import gtPlusPlus.api.interfaces.IPlugin; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.util.reflect.ReflectionUtils; + +public class Core_Manager { + + public static AutoMap<IPlugin> mPlugins = new AutoMap<>(); + + /** + * @param plugin - Dynamically registers the plugin for loading. + */ + public static void registerPlugin(IPlugin plugin) { + Logger.INFO("[Plugin] " + "Registered " + plugin.getPluginName() + "."); + mPlugins.put(plugin); + } + + /** + * Dynamically loads all class objects within the "gtPlusPlus.plugin" package. + */ + public static void veryEarlyInit() { + if (ReflectionUtils.dynamicallyLoadClassesInPackage("gtPlusPlus.plugin")) { + Logger.INFO("[Plugin] Plugin System loaded."); + } + } + + public static boolean preInit() { + try { + for (IPlugin h : mPlugins) { + if (h.preInit()) { + Logger.INFO("[Plugin] Completed Pre-Init Phase for " + h.getPluginName() + "."); + } else { + Logger.INFO("[Plugin] Failed during Pre-Init Phase for " + h.getPluginName() + "."); + } + } + return true; + } catch (Throwable ignored) {} + return false; + } + + public static boolean init() { + try { + for (IPlugin h : mPlugins) { + if (h.init()) { + Logger.INFO("[Plugin] Completed Init Phase for " + h.getPluginName() + "."); + } else { + Logger.INFO("[Plugin] Failed during Init Phase for " + h.getPluginName() + "."); + } + } + return true; + } catch (Throwable ignored) {} + return false; + } + + public static boolean postInit() { + try { + for (IPlugin h : mPlugins) { + if (h.postInit()) { + Logger.INFO("[Plugin] Completed Post-Init Phase for " + h.getPluginName() + "."); + } else { + Logger.INFO("[Plugin] Failed during Post-Init Phase for " + h.getPluginName() + "."); + } + } + return true; + } catch (Throwable ignored) {} + return false; + } + + public static void serverStart() { + try { + for (IPlugin h : mPlugins) { + if (h.serverStart()) { + Logger.INFO("[Plugin] Completed Server Start Phase for " + h.getPluginName() + "."); + } else { + Logger.INFO("[Plugin] Failed during Server Start Phase for " + h.getPluginName() + "."); + } + } + } catch (Throwable ignored) {} + } + + public static void serverStop() { + try { + for (IPlugin h : mPlugins) { + if (h.serverStop()) { + Logger.INFO("[Plugin] Completed Server Stop Phase for " + h.getPluginName() + "."); + } else { + Logger.INFO("[Plugin] Failed during Server Stop Phase for " + h.getPluginName() + "."); + } + } + } catch (Throwable ignored) {} + } +} |