From 8aa595f083b5c3e43246119fca5f4263f81e851b Mon Sep 17 00:00:00 2001 From: Raven Szewczyk Date: Sat, 25 May 2024 14:42:41 +0100 Subject: Migrate kubatech source code --- src/main/java/kubatech/loaders/BlockLoader.java | 51 +++ src/main/java/kubatech/loaders/DEFCRecipes.java | 329 +++++++++++++++++++ src/main/java/kubatech/loaders/ItemLoader.java | 149 +++++++++ src/main/java/kubatech/loaders/MTLoader.java | 44 +++ .../java/kubatech/loaders/MobHandlerLoader.java | 306 +++++++++++++++++ src/main/java/kubatech/loaders/RecipeLoader.java | 363 +++++++++++++++++++++ src/main/java/kubatech/loaders/TCLoader.java | 151 +++++++++ .../loaders/block/defc/DEFCCasingBlock.java | 63 ++++ .../loaders/block/defc/DEFCCasingItemBlock.java | 36 ++ .../loaders/block/kubablock/BlockProxy.java | 111 +++++++ .../block/kubablock/IProxyTileEntityProvider.java | 29 ++ .../loaders/block/kubablock/KubaBlock.java | 198 +++++++++++ .../loaders/block/kubablock/KubaItemBlock.java | 73 +++++ .../block/kubablock/blocks/TeaAcceptor.java | 64 ++++ .../loaders/block/kubablock/blocks/TeaStorage.java | 66 ++++ .../java/kubatech/loaders/item/IItemProxyGUI.java | 31 ++ src/main/java/kubatech/loaders/item/ItemProxy.java | 122 +++++++ src/main/java/kubatech/loaders/item/KubaItems.java | 144 ++++++++ src/main/java/kubatech/loaders/item/items/Tea.java | 72 ++++ .../kubatech/loaders/item/items/TeaCollection.java | 209 ++++++++++++ .../kubatech/loaders/item/items/TeaIngredient.java | 41 +++ .../kubatech/loaders/item/items/TeaUltimate.java | 216 ++++++++++++ 22 files changed, 2868 insertions(+) create mode 100644 src/main/java/kubatech/loaders/BlockLoader.java create mode 100644 src/main/java/kubatech/loaders/DEFCRecipes.java create mode 100644 src/main/java/kubatech/loaders/ItemLoader.java create mode 100644 src/main/java/kubatech/loaders/MTLoader.java create mode 100644 src/main/java/kubatech/loaders/MobHandlerLoader.java create mode 100644 src/main/java/kubatech/loaders/RecipeLoader.java create mode 100644 src/main/java/kubatech/loaders/TCLoader.java create mode 100644 src/main/java/kubatech/loaders/block/defc/DEFCCasingBlock.java create mode 100644 src/main/java/kubatech/loaders/block/defc/DEFCCasingItemBlock.java create mode 100644 src/main/java/kubatech/loaders/block/kubablock/BlockProxy.java create mode 100644 src/main/java/kubatech/loaders/block/kubablock/IProxyTileEntityProvider.java create mode 100644 src/main/java/kubatech/loaders/block/kubablock/KubaBlock.java create mode 100644 src/main/java/kubatech/loaders/block/kubablock/KubaItemBlock.java create mode 100644 src/main/java/kubatech/loaders/block/kubablock/blocks/TeaAcceptor.java create mode 100644 src/main/java/kubatech/loaders/block/kubablock/blocks/TeaStorage.java create mode 100644 src/main/java/kubatech/loaders/item/IItemProxyGUI.java create mode 100644 src/main/java/kubatech/loaders/item/ItemProxy.java create mode 100644 src/main/java/kubatech/loaders/item/KubaItems.java create mode 100644 src/main/java/kubatech/loaders/item/items/Tea.java create mode 100644 src/main/java/kubatech/loaders/item/items/TeaCollection.java create mode 100644 src/main/java/kubatech/loaders/item/items/TeaIngredient.java create mode 100644 src/main/java/kubatech/loaders/item/items/TeaUltimate.java (limited to 'src/main/java/kubatech/loaders') diff --git a/src/main/java/kubatech/loaders/BlockLoader.java b/src/main/java/kubatech/loaders/BlockLoader.java new file mode 100644 index 0000000000..fcb077ff15 --- /dev/null +++ b/src/main/java/kubatech/loaders/BlockLoader.java @@ -0,0 +1,51 @@ +/* + * spotless:off + * KubaTech - Gregtech Addon + * Copyright (C) 2022 - 2024 kuba6000 + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library. If not, see . + * spotless:on + */ + +package kubatech.loaders; + +import net.minecraft.block.material.Material; +import net.minecraft.item.ItemBlock; + +import cpw.mods.fml.common.registry.GameRegistry; +import kubatech.api.enums.ItemList; +import kubatech.loaders.block.defc.DEFCCasingBlock; +import kubatech.loaders.block.kubablock.KubaBlock; +import kubatech.loaders.block.kubablock.KubaItemBlock; +import kubatech.loaders.block.kubablock.blocks.TeaAcceptor; +import kubatech.loaders.block.kubablock.blocks.TeaStorage; +import kubatech.tileentity.TeaAcceptorTile; +import kubatech.tileentity.TeaStorageTile; + +public class BlockLoader { + + public static final KubaBlock kubaBlock = new KubaBlock(Material.anvil); + public static final ItemBlock kubaItemBlock = new KubaItemBlock(kubaBlock); + public static final DEFCCasingBlock defcCasingBlock = new DEFCCasingBlock(); + + public static void registerBlocks() { + GameRegistry.registerTileEntity(TeaAcceptorTile.class, "KT_TeaAcceptor"); + GameRegistry.registerTileEntity(TeaStorageTile.class, "KT_TeaStorage"); + GameRegistry.registerBlock(kubaBlock, null, "kubablocks"); + GameRegistry.registerItem(kubaItemBlock, "kubablocks"); + + ItemList.TeaAcceptor.set(kubaBlock.registerProxyBlock(new TeaAcceptor())); + ItemList.TeaStorage.set(kubaBlock.registerProxyBlock(new TeaStorage())); + } +} diff --git a/src/main/java/kubatech/loaders/DEFCRecipes.java b/src/main/java/kubatech/loaders/DEFCRecipes.java new file mode 100644 index 0000000000..f7805ec84f --- /dev/null +++ b/src/main/java/kubatech/loaders/DEFCRecipes.java @@ -0,0 +1,329 @@ +package kubatech.loaders; + +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.mixerRecipes; + +import java.util.Arrays; + +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import com.gtnewhorizons.modularui.api.drawable.UITexture; + +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.recipe.RecipeMap; +import gregtech.api.recipe.RecipeMapBackend; +import gregtech.api.recipe.RecipeMapBuilder; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import gregtech.nei.formatter.SimpleSpecialValueFormatter; +import gtPlusPlus.xmod.forestry.bees.handler.GTPP_CombType; +import kubatech.Tags; +import kubatech.api.LoaderReference; + +public class DEFCRecipes { + + public static final RecipeMap fusionCraftingRecipes = RecipeMapBuilder + .of("kubatech.defusioncrafter") + .maxIO(9, 1, 1, 1) + .minInputs(1, 0) + .neiSpecialInfoFormatter(new SimpleSpecialValueFormatter("kubatech.defusioncrafter.tier")) + .slotOverlays( + (index, isFluid, isOutput, + isSpecial) -> !isFluid && !isOutput ? UITexture.fullImage(Tags.MODID, "gui/slot/fusion_crafter") : null) + .build(); + + public static void addRecipes() { + + // Dragonblood recipe for magics haters + if (LoaderReference.GTPlusPlus) { + GT_Values.RA.stdBuilder() + .itemInputs( + new ItemStack(Blocks.dragon_egg, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DraconiumAwakened, 64L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DraconiumAwakened, 64L)) + .fluidInputs(Materials.Radon.getPlasma(144)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Ash, 8L)) + .fluidOutputs(new FluidStack(FluidRegistry.getFluid("molten.dragonblood"), 288)) + .eut(1_966_080) + .duration(14_000) + .addTo(mixerRecipes); + } + + // Casings + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.NaquadahAlloy, 6L), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.NaquadahAlloy, 6L)) + .fluidInputs(Materials.Void.getMolten(1152L)) + .itemOutputs(kubatech.api.enums.ItemList.DEFCCasingBase.get(1)) + .eut(491_520) + .duration(24000) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "tile.BloodyIchorium", 1, 0), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Osmiridium, 6L)) + .fluidInputs(Materials.Void.getMolten(1152L)) + .itemOutputs(kubatech.api.enums.ItemList.DEFCCasingT1.get(1)) + .eut(491_520) + .duration(24000) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + kubatech.api.enums.ItemList.DEFCCasingT1.get(1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Draconium, 6L), + GT_ModHandler.getModItem("DraconicEvolution", "draconicCore", 1, 0)) + .fluidInputs(Materials.Void.getMolten(2304L)) + .itemOutputs(kubatech.api.enums.ItemList.DEFCCasingT2.get(1)) + .eut(491_520) + .duration(24000) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + kubatech.api.enums.ItemList.DEFCCasingT2.get(1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.CosmicNeutronium, 6L), + GT_ModHandler.getModItem("DraconicEvolution", "wyvernCore", 2, 0)) + .fluidInputs(Materials.Void.getMolten(4608L)) + .itemOutputs(kubatech.api.enums.ItemList.DEFCCasingT3.get(1)) + .eut(1_996_080) + .duration(12000) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + kubatech.api.enums.ItemList.DEFCCasingT3.get(1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.DraconiumAwakened, 6L), + GT_ModHandler.getModItem("DraconicEvolution", "awakenedCore", 3, 0)) + .fluidInputs(Materials.Void.getMolten(9216L)) + .itemOutputs(kubatech.api.enums.ItemList.DEFCCasingT4.get(1)) + .eut(7_864_320) + .duration(12000) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + kubatech.api.enums.ItemList.DEFCCasingT4.get(1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Infinity, 6L), + GT_ModHandler.getModItem("DraconicEvolution", "chaoticCore", 4, 0)) + .fluidInputs(Materials.Void.getMolten(18432L)) + .itemOutputs(kubatech.api.enums.ItemList.DEFCCasingT5.get(1)) + .eut(31_457_280) + .duration(12000) + .addTo(assemblerRecipes); + + fusionRecipes(); + conversionRecipes(); + } + + private static final Item EMTItems = GameRegistry.findItem("EMT", "EMTItems"); + + private static void addOldHiddenRecipe(GT_Recipe recipe) { + if (!LoaderReference.ElectroMagicTools) return; + recipe = recipe.copy(); + recipe.mInputs = Arrays.stream(recipe.mInputs) + .map(i -> { + if (i != null && i.getItem() == ItemLoader.kubaitems) { + return new ItemStack( + EMTItems, + 0, + 16 + (i.getItemDamage() - kubatech.api.enums.ItemList.DEFCDraconicSchematic.get(1) + .getItemDamage())); + } else return i; + }) + .toArray(ItemStack[]::new); + recipe.mHidden = true; + fusionCraftingRecipes.add(recipe); + } + + private static void conversionRecipes() { + if (!LoaderReference.ElectroMagicTools) return; + GameRegistry.addShapelessRecipe( + kubatech.api.enums.ItemList.DEFCDraconicSchematic.get(1), + new ItemStack(EMTItems, 1, 16)); + GameRegistry + .addShapelessRecipe(kubatech.api.enums.ItemList.DEFCWyvernSchematic.get(1), new ItemStack(EMTItems, 1, 17)); + GameRegistry.addShapelessRecipe( + kubatech.api.enums.ItemList.DEFCAwakenedSchematic.get(1), + new ItemStack(EMTItems, 1, 18)); + GameRegistry.addShapelessRecipe( + kubatech.api.enums.ItemList.DEFCChaoticSchematic.get(1), + new ItemStack(EMTItems, 1, 19)); + } + + private static void fusionRecipes() { + // CORES + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Osmiridium, 4), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Ichorium, 1), + ItemList.QuantumEye.get(1L), + kubatech.api.enums.ItemList.DEFCDraconicSchematic.get(0L)) + .fluidInputs(Materials.Sunnarium.getMolten(1440)) + .itemOutputs(GT_ModHandler.getModItem("DraconicEvolution", "draconicCore", 1, 0)) + .eut(500_000) + .duration(400) + .specialValue(1) + .addTo(fusionCraftingRecipes) + .forEach(DEFCRecipes::addOldHiddenRecipe); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Draconium, 8), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Neutronium, 4), + GT_ModHandler.getModItem("DraconicEvolution", "draconicCore", 4, 0), + ItemList.QuantumStar.get(1L), + kubatech.api.enums.ItemList.DEFCWyvernSchematic.get(0L)) + .fluidInputs(Materials.Neutronium.getMolten(1440)) + .itemOutputs(GT_ModHandler.getModItem("DraconicEvolution", "wyvernCore", 1, 0)) + .eut(2_000_000) + .duration(800) + .specialValue(2) + .addTo(fusionCraftingRecipes) + .forEach(DEFCRecipes::addOldHiddenRecipe); + + if (Loader.isModLoaded("supersolarpanel")) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.DraconiumAwakened, 12), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Draconium, 4), + GT_ModHandler.getModItem("DraconicEvolution", "wyvernCore", 4, 0), + GT_ModHandler.getModItem("supersolarpanel", "enderquantumcomponent", 1, 0), + kubatech.api.enums.ItemList.DEFCAwakenedSchematic.get(0L)) + .fluidInputs(Materials.Infinity.getMolten(1440)) + .itemOutputs(GT_ModHandler.getModItem("DraconicEvolution", "awakenedCore", 1, 0)) + .eut(8_000_000) + .duration(1600) + .specialValue(3) + .addTo(fusionCraftingRecipes) + .forEach(DEFCRecipes::addOldHiddenRecipe); + } else { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.DraconiumAwakened, 12), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Draconium, 4), + GT_ModHandler.getModItem("DraconicEvolution", "wyvernCore", 4, 0), + GT_ModHandler.getModItem("dreamcraft", "item.ManyullynCrystal", 1, 0), + kubatech.api.enums.ItemList.DEFCAwakenedSchematic.get(0L)) + .fluidInputs(Materials.Infinity.getMolten(1440)) + .itemOutputs(GT_ModHandler.getModItem("DraconicEvolution", "awakenedCore", 1, 0)) + .eut(8_000_000) + .duration(1600) + .specialValue(3) + .addTo(fusionCraftingRecipes) + .forEach(DEFCRecipes::addOldHiddenRecipe); + } + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.DraconiumAwakened, 16), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.BlackPlutonium, 4), + GT_ModHandler.getModItem("DraconicEvolution", "awakenedCore", 4, 0), + GT_ModHandler.getModItem("DraconicEvolution", "chaosFragment", 2, 2), + kubatech.api.enums.ItemList.DEFCChaoticSchematic.get(0L)) + .fluidInputs(MaterialsUEVplus.SpaceTime.getMolten(1440)) + .itemOutputs(GT_ModHandler.getModItem("DraconicEvolution", "chaoticCore", 1, 0)) + .eut(24_000_000) + .duration(3200) + .specialValue(4) + .addTo(fusionCraftingRecipes) + .forEach(DEFCRecipes::addOldHiddenRecipe); + + // ENERGY CORES + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Draconium, 8), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.StellarAlloy, 4), + GT_ModHandler.getModItem("AdvancedSolarPanel", "asp_crafting_items", 4, 1), + GT_ModHandler.getModItem("DraconicEvolution", "draconicCore", 1, 0), + kubatech.api.enums.ItemList.DEFCWyvernSchematic.get(0L)) + .itemOutputs(GT_ModHandler.getModItem("DraconicEvolution", "draconiumEnergyCore", 1, 0)) + .eut(500_000) + .duration(1000) + .specialValue(2) + .addTo(fusionCraftingRecipes) + .forEach(DEFCRecipes::addOldHiddenRecipe); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.DraconiumAwakened, 8), + GT_ModHandler.getModItem("DraconicEvolution", "draconiumEnergyCore", 4, 0), + GT_ModHandler.getModItem("AdvancedSolarPanel", "asp_crafting_items", 4, 4), + GT_ModHandler.getModItem("DraconicEvolution", "wyvernCore", 1, 0), + kubatech.api.enums.ItemList.DEFCAwakenedSchematic.get(0L)) + .itemOutputs(GT_ModHandler.getModItem("DraconicEvolution", "draconiumEnergyCore", 1, 1)) + .eut(2_000_000) + .duration(2000) + .specialValue(3) + .addTo(fusionCraftingRecipes) + .forEach(DEFCRecipes::addOldHiddenRecipe); + + // Dragon Blood + if (LoaderReference.GTPlusPlus) { + + GT_Values.RA.stdBuilder() + .itemInputs( + new ItemStack(Blocks.dragon_egg, 0), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DraconiumAwakened, 64), + GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Radon.getPlasma(144)) + .fluidOutputs(new FluidStack(FluidRegistry.getFluid("molten.dragonblood"), 288)) + .eut(1_966_080) + .duration(4200) + .specialValue(3) + .noOptimize() + .addTo(fusionCraftingRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("witchery", "infinityegg", 0), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DraconiumAwakened, 64), + GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Radon.getPlasma(72)) + .fluidOutputs(new FluidStack(FluidRegistry.getFluid("molten.dragonblood"), 432)) + .eut(1_966_080) + .duration(3600) + .specialValue(3) + .noOptimize() + .addTo(fusionCraftingRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + new ItemStack(Blocks.dragon_egg, 0), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DraconiumAwakened, 64), + GTPP_CombType.DRAGONBLOOD.getStackForType(1)) + .fluidInputs(Materials.Radon.getPlasma(216)) + .fluidOutputs(new FluidStack(FluidRegistry.getFluid("molten.dragonblood"), 432)) + .eut(1_966_080) + .duration(2800) + .specialValue(3) + .noOptimize() + .addTo(fusionCraftingRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("witchery", "infinityegg", 0), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DraconiumAwakened, 64), + GTPP_CombType.DRAGONBLOOD.getStackForType(1)) + .fluidInputs(Materials.Radon.getPlasma(108)) + .fluidOutputs(new FluidStack(FluidRegistry.getFluid("molten.dragonblood"), 648)) + .eut(1_966_080) + .duration(2400) + .specialValue(3) + .noOptimize() + .addTo(fusionCraftingRecipes); + } + } +} diff --git a/src/main/java/kubatech/loaders/ItemLoader.java b/src/main/java/kubatech/loaders/ItemLoader.java new file mode 100644 index 0000000000..d8218ea873 --- /dev/null +++ b/src/main/java/kubatech/loaders/ItemLoader.java @@ -0,0 +1,149 @@ +/* + * spotless:off + * KubaTech - Gregtech Addon + * Copyright (C) 2022 - 2024 kuba6000 + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library. If not, see . + * spotless:on + */ + +package kubatech.loaders; + +import static kubatech.api.enums.ItemList.Beeeeee; +import static kubatech.api.enums.ItemList.BlackTea; +import static kubatech.api.enums.ItemList.BlackTeaLeaf; +import static kubatech.api.enums.ItemList.BruisedTeaLeaf; +import static kubatech.api.enums.ItemList.DEFCAwakenedSchematic; +import static kubatech.api.enums.ItemList.DEFCChaoticSchematic; +import static kubatech.api.enums.ItemList.DEFCDraconicSchematic; +import static kubatech.api.enums.ItemList.DEFCWyvernSchematic; +import static kubatech.api.enums.ItemList.EarlGrayTea; +import static kubatech.api.enums.ItemList.FermentedTeaLeaf; +import static kubatech.api.enums.ItemList.GreenTea; +import static kubatech.api.enums.ItemList.GreenTeaLeaf; +import static kubatech.api.enums.ItemList.LegendaryBlackTea; +import static kubatech.api.enums.ItemList.LegendaryButterflyTea; +import static kubatech.api.enums.ItemList.LegendaryEarlGrayTea; +import static kubatech.api.enums.ItemList.LegendaryGreenTea; +import static kubatech.api.enums.ItemList.LegendaryLemonTea; +import static kubatech.api.enums.ItemList.LegendaryMilkTea; +import static kubatech.api.enums.ItemList.LegendaryOolongTea; +import static kubatech.api.enums.ItemList.LegendaryPeppermintTea; +import static kubatech.api.enums.ItemList.LegendaryPuerhTea; +import static kubatech.api.enums.ItemList.LegendaryRedTea; +import static kubatech.api.enums.ItemList.LegendaryUltimateTea; +import static kubatech.api.enums.ItemList.LegendaryWhiteTea; +import static kubatech.api.enums.ItemList.LegendaryYellowTea; +import static kubatech.api.enums.ItemList.LemonTea; +import static kubatech.api.enums.ItemList.MilkTea; +import static kubatech.api.enums.ItemList.OolongTea; +import static kubatech.api.enums.ItemList.OolongTeaLeaf; +import static kubatech.api.enums.ItemList.OxidizedTeaLeaf; +import static kubatech.api.enums.ItemList.PartiallyOxidizedTeaLeaf; +import static kubatech.api.enums.ItemList.PeppermintTea; +import static kubatech.api.enums.ItemList.PuerhTea; +import static kubatech.api.enums.ItemList.PuerhTeaLeaf; +import static kubatech.api.enums.ItemList.RolledTeaLeaf; +import static kubatech.api.enums.ItemList.SteamedTeaLeaf; +import static kubatech.api.enums.ItemList.TeaAcceptorResearchNote; +import static kubatech.api.enums.ItemList.TeaLeafDehydrated; +import static kubatech.api.enums.ItemList.WhiteTea; +import static kubatech.api.enums.ItemList.WhiteTeaLeaf; +import static kubatech.api.enums.ItemList.YellowTea; +import static kubatech.api.enums.ItemList.YellowTeaLeaf; + +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; + +import cpw.mods.fml.common.registry.GameRegistry; +import kubatech.loaders.item.ItemProxy; +import kubatech.loaders.item.KubaItems; +import kubatech.loaders.item.items.Tea; +import kubatech.loaders.item.items.TeaCollection; +import kubatech.loaders.item.items.TeaIngredient; +import kubatech.loaders.item.items.TeaUltimate; + +public class ItemLoader { + + public static final KubaItems kubaitems = new KubaItems(); + + public static void registerItems() { + GameRegistry.registerItem(kubaitems, "kubaitems"); + + // DON'T EVER CHANGE ORDER IN HERE, ADD NEW ITEMS ON BOTTOM + + LegendaryBlackTea.set(kubaitems.registerProxyItem(new TeaCollection("black_tea"))); + LegendaryButterflyTea.set(kubaitems.registerProxyItem(new TeaCollection("butterfly_tea"))); + LegendaryEarlGrayTea.set(kubaitems.registerProxyItem(new TeaCollection("earl_gray_tea"))); + LegendaryGreenTea.set(kubaitems.registerProxyItem(new TeaCollection("green_tea"))); + LegendaryLemonTea.set(kubaitems.registerProxyItem(new TeaCollection("lemon_tea"))); + LegendaryMilkTea.set(kubaitems.registerProxyItem(new TeaCollection("milk_tea"))); + LegendaryOolongTea.set(kubaitems.registerProxyItem(new TeaCollection("oolong_tea"))); + LegendaryPeppermintTea.set(kubaitems.registerProxyItem(new TeaCollection("peppermint_tea"))); + LegendaryPuerhTea.set(kubaitems.registerProxyItem(new TeaCollection("pu-erh_tea"))); + LegendaryRedTea.set(kubaitems.registerProxyItem(new TeaCollection("red_tea"))); + LegendaryWhiteTea.set(kubaitems.registerProxyItem(new TeaCollection("white_tea"))); + LegendaryYellowTea.set(kubaitems.registerProxyItem(new TeaCollection("yellow_tea"))); + LegendaryUltimateTea.set(kubaitems.registerProxyItem(new TeaUltimate())); + + BlackTea.set(kubaitems.registerProxyItem(new Tea("black_tea", 4, 0.3f))); + EarlGrayTea.set(kubaitems.registerProxyItem(new Tea("earl_gray_tea", 4, 0.3f))); + GreenTea.set(kubaitems.registerProxyItem(new Tea("green_tea", 4, 0.3f))); + LemonTea.set(kubaitems.registerProxyItem(new Tea("lemon_tea", 4, 0.3f))); + MilkTea.set(kubaitems.registerProxyItem(new Tea("milk_tea", 4, 0.3f))); + OolongTea.set(kubaitems.registerProxyItem(new Tea("oolong_tea", 4, 0.3f))); + PeppermintTea.set(kubaitems.registerProxyItem(new Tea("peppermint_tea", 4, 0.3f))); + PuerhTea.set(kubaitems.registerProxyItem(new Tea("pu-erh_tea", 4, 0.3f))); + WhiteTea.set(kubaitems.registerProxyItem(new Tea("white_tea", 4, 0.3f))); + YellowTea.set(kubaitems.registerProxyItem(new Tea("yellow_tea", 4, 0.3f))); + + BlackTeaLeaf.set(kubaitems.registerProxyItem(new TeaIngredient("black_tea_leaf"))); + GreenTeaLeaf.set(kubaitems.registerProxyItem(new TeaIngredient("green_tea_leaf"))); + OolongTeaLeaf.set(kubaitems.registerProxyItem(new TeaIngredient("oolong_tea_leaf"))); + PuerhTeaLeaf.set(kubaitems.registerProxyItem(new TeaIngredient("pu-erh_tea_leaf"))); + WhiteTeaLeaf.set(kubaitems.registerProxyItem(new TeaIngredient("white_tea_leaf"))); + YellowTeaLeaf.set(kubaitems.registerProxyItem(new TeaIngredient("yellow_tea_leaf"))); + + TeaLeafDehydrated.set(kubaitems.registerProxyItem(new TeaIngredient("tea_leaf_dehydrated"))); + SteamedTeaLeaf.set(kubaitems.registerProxyItem(new TeaIngredient("steamed_tea_leaf"))); + RolledTeaLeaf.set(kubaitems.registerProxyItem(new TeaIngredient("rolled_tea_leaf"))); + OxidizedTeaLeaf.set(kubaitems.registerProxyItem(new TeaIngredient("oxidized_tea_leaf"))); + FermentedTeaLeaf.set(kubaitems.registerProxyItem(new TeaIngredient("fermented_tea_leaf"))); + BruisedTeaLeaf.set(kubaitems.registerProxyItem(new TeaIngredient("bruised_tea_leaf"))); + PartiallyOxidizedTeaLeaf.set(kubaitems.registerProxyItem(new TeaIngredient("partially_oxidized_tea_leaf"))); + + TeaAcceptorResearchNote + .set(kubaitems.registerProxyItem(new ItemProxy("tea_acceptor_research_note", "research_note"))); + Beeeeee.set(kubaitems.registerProxyItem(new ItemProxy("beeeeee"))); + + // DEFC stuff + DEFCDraconicSchematic.set(kubaitems.registerProxyItem(new ItemProxy("defc_schematic_t1") { + + @Override + public void addInformation(ItemStack stack, EntityPlayer entity, List tooltipList, + boolean showDebugInfo) { + tooltipList + .add(EnumChatFormatting.GOLD + StatCollector.translateToLocal("kubaitem.defc_schematic_t1.tip")); + } + })); + DEFCWyvernSchematic.set(kubaitems.registerProxyItem(new ItemProxy("defc_schematic_t2"))); + DEFCAwakenedSchematic.set(kubaitems.registerProxyItem(new ItemProxy("defc_schematic_t3"))); + DEFCChaoticSchematic.set(kubaitems.registerProxyItem(new ItemProxy("defc_schematic_t4"))); + + } +} diff --git a/src/main/java/kubatech/loaders/MTLoader.java b/src/main/java/kubatech/loaders/MTLoader.java new file mode 100644 index 0000000000..dbc5bb43fe --- /dev/null +++ b/src/main/java/kubatech/loaders/MTLoader.java @@ -0,0 +1,44 @@ +/* + * spotless:off + * KubaTech - Gregtech Addon + * Copyright (C) 2022 - 2024 kuba6000 + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library. If not, see . + * spotless:on + */ + +package kubatech.loaders; + +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import kubatech.Tags; +import minetweaker.MineTweakerImplementationAPI; + +public class MTLoader { + + private static final Logger LOG = LogManager.getLogger(Tags.MODID + "[MT Loader]"); + public static MTLoader instance = null; + + public static void init() { + if (instance == null) { + instance = new MTLoader(); + MineTweakerImplementationAPI.onPostReload(instance::MTOnPostReload); + } + } + + public void MTOnPostReload(MineTweakerImplementationAPI.ReloadEvent reloadEvent) { + LOG.info("MT Recipes Loaded!"); + } +} diff --git a/src/main/java/kubatech/loaders/MobHandlerLoader.java b/src/main/java/kubatech/loaders/MobHandlerLoader.java new file mode 100644 index 0000000000..e7e4ff1736 --- /dev/null +++ b/src/main/java/kubatech/loaders/MobHandlerLoader.java @@ -0,0 +1,306 @@ +/* + * spotless:off + * KubaTech - Gregtech Addon + * Copyright (C) 2022 - 2024 kuba6000 + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library. If not, see . + * spotless:on + */ + +package kubatech.loaders; + +import static kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_ExtremeEntityCrusher.DIAMOND_SPIKES_DAMAGE; +import static kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_ExtremeEntityCrusher.MOB_SPAWN_INTERVAL; + +import java.lang.reflect.InvocationTargetException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Random; + +import net.minecraft.enchantment.EnchantmentHelper; +import net.minecraft.entity.EntityList; +import net.minecraft.entity.EntityLiving; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.JsonToNBT; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.StatCollector; +import net.minecraftforge.common.MinecraftForge; + +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import com.dreammaster.main.MainRegistry; +import com.dreammaster.modcustomdrops.CustomDrops; +import com.kuba6000.mobsinfo.api.IChanceModifier; +import com.kuba6000.mobsinfo.api.MobDrop; +import com.kuba6000.mobsinfo.api.MobOverride; +import com.kuba6000.mobsinfo.api.MobRecipe; +import com.kuba6000.mobsinfo.api.event.MobNEIRegistrationEvent; +import com.kuba6000.mobsinfo.api.event.PostMobRegistrationEvent; +import com.kuba6000.mobsinfo.api.event.PostMobsOverridesLoadEvent; +import com.kuba6000.mobsinfo.api.event.PreMobsRegistrationEvent; + +import atomicstryker.infernalmobs.common.InfernalMobsCore; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.util.GT_Utility; +import kubatech.Tags; +import kubatech.api.LoaderReference; +import kubatech.api.helpers.ReflectionHelper; +import kubatech.config.Config; +import kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_ExtremeEntityCrusher; + +public class MobHandlerLoader { + + private static final Logger LOG = LogManager.getLogger(Tags.MODID + "[Mob Handler Loader]"); + + private static MobHandlerLoader instance = null; + + public static void init() { + instance = new MobHandlerLoader(); + MinecraftForge.EVENT_BUS.register(instance); + } + + public static Map recipeMap = new HashMap<>(); + + public static class MobEECRecipe { + + public final List mOutputs; + + public final MobRecipe recipe; + + public final int mEUt = 2000; + public final int mDuration; + public final EntityLiving entityCopy; + + public MobEECRecipe(List transformedDrops, MobRecipe recipe) { + this.mOutputs = transformedDrops; + this.recipe = recipe; + try { + this.entityCopy = this.recipe.createEntityCopy(); + } catch (NoSuchMethodException | InvocationTargetException | InstantiationException + | IllegalAccessException e) { + throw new RuntimeException(e); + } + mDuration = Math.max(MOB_SPAWN_INTERVAL, (int) ((recipe.maxEntityHealth / DIAMOND_SPIKES_DAMAGE) * 10d)); + } + + public ItemStack[] generateOutputs(Random rnd, GT_MetaTileEntity_ExtremeEntityCrusher MTE, double attackDamage, + int lootinglevel, boolean preferInfernalDrops, boolean voidAllDamagedAndEnchantedItems) { + MTE.lEUt = mEUt; + MTE.mMaxProgresstime = Math.max(MOB_SPAWN_INTERVAL, (int) ((recipe.maxEntityHealth / attackDamage) * 10d)); + ArrayList stacks = new ArrayList<>(this.mOutputs.size()); + this.entityCopy.setPosition( + MTE.getBaseMetaTileEntity() + .getXCoord(), + MTE.getBaseMetaTileEntity() + .getYCoord(), + MTE.getBaseMetaTileEntity() + .getZCoord()); + for (MobDrop o : this.mOutputs) { + if (voidAllDamagedAndEnchantedItems && (o.damages != null || o.enchantable != null)) continue; + int chance = o.chance; + + double dChance = (double) chance / 100d; + for (IChanceModifier chanceModifier : o.chanceModifiers) { + dChance = chanceModifier.apply( + dChance, + MTE.getBaseMetaTileEntity() + .getWorld(), + stacks, + MTE.EECPlayer, + this.entityCopy); + } + + chance = (int) (dChance * 100d); + if (chance == 0) continue; + + if (o.playerOnly) { + chance = (int) ((double) chance * Config.MobHandler.playerOnlyDropsModifier); + if (chance < 1) chance = 1; + } + int amount = o.stack.stackSize; + if (o.lootable && lootinglevel > 0) { + chance += lootinglevel * 5000; + if (chance > 10000) { + int div = (int) Math.ceil(chance / 10000d); + amount *= div; + chance /= div; + } + } + if (chance == 10000 || rnd.nextInt(10000) < chance) { + ItemStack s = o.stack.copy(); + s.stackSize = amount; + if (o.enchantable != null) EnchantmentHelper.addRandomEnchantment(rnd, s, o.enchantable); + if (o.damages != null) { + int rChance = rnd.nextInt(recipe.mMaxDamageChance); + int cChance = 0; + for (Map.Entry damage : o.damages.entrySet()) { + cChance += damage.getValue(); + if (rChance <= cChance) { + s.setItemDamage(damage.getKey()); + break; + } + } + } + stacks.add(s); + } + } + + if (LoaderReference.InfernalMobs) { + InfernalMobsCore infernalMobsCore = InfernalMobsCore.instance(); + if (recipe.infernalityAllowed && mEUt * 8 <= MTE.getMaxInputEu() + && !infernalMobsCore.getDimensionBlackList() + .contains( + MTE.getBaseMetaTileEntity() + .getWorld().provider.dimensionId)) { + int p = 0; + int mods = 0; + if (recipe.alwaysinfernal + || (preferInfernalDrops && rnd.nextInt(infernalMobsCore.getEliteRarity()) == 0)) { + p = 1; + if (rnd.nextInt(infernalMobsCore.getUltraRarity()) == 0) { + p = 2; + if (rnd.nextInt(infernalMobsCore.getInfernoRarity()) == 0) p = 3; + } + } + ArrayList infernalstacks = null; + if (p > 0) if (p == 1) { + infernalstacks = infernalMobsCore.getDropIdListElite(); + mods = infernalMobsCore.getMinEliteModifiers(); + } else if (p == 2) { + infernalstacks = infernalMobsCore.getDropIdListUltra(); + mods = infernalMobsCore.getMinUltraModifiers(); + } else { + infernalstacks = infernalMobsCore.getDropIdListInfernal(); + mods = infernalMobsCore.getMinInfernoModifiers(); + } + if (infernalstacks != null) { + ItemStack infernalstack = infernalstacks.get(rnd.nextInt(infernalstacks.size())) + .copy(); + // noinspection ConstantConditions + EnchantmentHelper.addRandomEnchantment( + rnd, + infernalstack, + infernalstack.getItem() + .getItemEnchantability()); + stacks.add(infernalstack); + MTE.lEUt *= 8L; + MTE.mMaxProgresstime *= mods * InfernalMobsCore.instance() + .getMobModHealthFactor(); + } + } + } + + return stacks.toArray(new ItemStack[0]); + } + + } + + @SubscribeEvent + public void onPreMobsRegistration(PreMobsRegistrationEvent event) { + recipeMap.clear(); + } + + @SubscribeEvent + public void onPostMobRegistration(PostMobRegistrationEvent event) { + if (!event.drops.isEmpty() && event.recipe.isUsableInVial) { + @SuppressWarnings("unchecked") + ArrayList drops = (ArrayList) event.drops.clone(); + if (!drops.isEmpty()) { + recipeMap.put(event.currentMob, new MobEECRecipe(drops, event.recipe)); + } + } + } + + @SubscribeEvent + public void onPostOverridesConfigLoad(PostMobsOverridesLoadEvent event) { + if (LoaderReference.GTNHCoreMod) { + LOG.info("Detected GTNH Core Mod, parsing custom drops from there."); + CustomDrops coredrops = ReflectionHelper.getField(MainRegistry.Module_CustomDrops, "_mCustomDrops", null); + if (coredrops != null) { + @SuppressWarnings("unchecked") + ArrayList customdrops = (ArrayList) ((ArrayList) coredrops + .getCustomDrops()).clone(); + for (CustomDrops.CustomDrop customdrop : customdrops) { + try { + Class eclass = Class.forName(customdrop.getEntityName()); + if (!EntityLiving.class.isAssignableFrom(eclass)) continue; + String ename = (String) EntityList.classToStringMapping.get(eclass); + if (ename == null) continue; + MobOverride override = event.overrides.computeIfAbsent(ename, k -> new MobOverride()); + for (CustomDrops.CustomDrop.Drop drop : customdrop.getDrops()) { + String[] parts = drop.getItemName() + .split(":"); + ItemStack stack = GameRegistry.findItemStack(parts[0], parts[1], 1); + if (stack == null) continue; + if (parts.length > 2) stack.setItemDamage(Integer.parseInt(parts[2])); + String pNBT = ReflectionHelper.getField(drop, "mTag", null); + if (pNBT != null && !pNBT.isEmpty()) { + try { + stack.stackTagCompound = (NBTTagCompound) JsonToNBT.func_150315_a(pNBT); + } catch (Exception ignored) {} + } + int chance = drop.getChance() * 100; + int amount = drop.getAmount(); + if (drop.getIsRandomAmount()) { + // average chance formula + // chance *= ((((amount * (amount + 1d)) / 2d)) + 1d) / (amount + 1d); + chance *= (2d + (amount * amount) + amount) / (2d * (amount + 1d)); + amount = 1; + if (chance > 10000) { + int div = (int) Math.ceil(chance / 10000d); + amount *= div; + chance /= div; + } + } + stack.stackSize = amount; + // Drops from coremod are player only + MobDrop mobDrop = new MobDrop( + stack, + MobDrop.DropType.Normal, + chance, + null, + null, + false, + true); + mobDrop.additionalInfo.add( + StatCollector.translateToLocalFormatted( + "kubatech.mobhandler.eec_chance", + (((double) chance / 100d) * Config.MobHandler.playerOnlyDropsModifier))); + override.additions.add(mobDrop); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + } + } + + } + + @SubscribeEvent + public void onMobNEIRegistration(MobNEIRegistrationEvent event) { + MobEECRecipe recipe = recipeMap.get(event.mobName); + if (recipe != null) { + event.additionalInformation.addAll( + Arrays.asList( + GT_Utility.trans("153", "Usage: ") + GT_Utility.formatNumbers(recipe.mEUt) + " EU/t", + GT_Utility.trans("158", "Time: ") + GT_Utility.formatNumbers(recipe.mDuration / 20d) + " secs")); + } + } +} diff --git a/src/main/java/kubatech/loaders/RecipeLoader.java b/src/main/java/kubatech/loaders/RecipeLoader.java new file mode 100644 index 0000000000..be35f27df4 --- /dev/null +++ b/src/main/java/kubatech/loaders/RecipeLoader.java @@ -0,0 +1,363 @@ +/* + * spotless:off + * KubaTech - Gregtech Addon + * Copyright (C) 2022 - 2024 kuba6000 + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library. If not, see . + * spotless:on + */ + +package kubatech.loaders; + +import static gregtech.api.recipe.RecipeMaps.benderRecipes; +import static gregtech.api.recipe.RecipeMaps.cutterRecipes; +import static gregtech.api.recipe.RecipeMaps.mixerRecipes; +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.AssemblyLine; +import static gregtech.api.util.GT_RecipeConstants.RESEARCH_ITEM; +import static gregtech.api.util.GT_RecipeConstants.RESEARCH_TIME; +import static gregtech.api.util.GT_RecipeConstants.UniversalChemical; +import static kubatech.api.enums.ItemList.BlackTea; +import static kubatech.api.enums.ItemList.BlackTeaLeaf; +import static kubatech.api.enums.ItemList.BruisedTeaLeaf; +import static kubatech.api.enums.ItemList.DraconicEvolutionFusionCrafter; +import static kubatech.api.enums.ItemList.EarlGrayTea; +import static kubatech.api.enums.ItemList.ExtremeEntityCrusher; +import static kubatech.api.enums.ItemList.ExtremeIndustrialApiary; +import static kubatech.api.enums.ItemList.ExtremeIndustrialGreenhouse; +import static kubatech.api.enums.ItemList.FermentedTeaLeaf; +import static kubatech.api.enums.ItemList.GreenTea; +import static kubatech.api.enums.ItemList.GreenTeaLeaf; +import static kubatech.api.enums.ItemList.LegendaryUltimateTea; +import static kubatech.api.enums.ItemList.LemonTea; +import static kubatech.api.enums.ItemList.MilkTea; +import static kubatech.api.enums.ItemList.OolongTea; +import static kubatech.api.enums.ItemList.OolongTeaLeaf; +import static kubatech.api.enums.ItemList.OxidizedTeaLeaf; +import static kubatech.api.enums.ItemList.PartiallyOxidizedTeaLeaf; +import static kubatech.api.enums.ItemList.PeppermintTea; +import static kubatech.api.enums.ItemList.PuerhTea; +import static kubatech.api.enums.ItemList.PuerhTeaLeaf; +import static kubatech.api.enums.ItemList.RolledTeaLeaf; +import static kubatech.api.enums.ItemList.SteamedTeaLeaf; +import static kubatech.api.enums.ItemList.TeaAcceptor; +import static kubatech.api.enums.ItemList.TeaAcceptorResearchNote; +import static kubatech.api.enums.ItemList.TeaLeafDehydrated; +import static kubatech.api.enums.ItemList.WhiteTea; +import static kubatech.api.enums.ItemList.WhiteTeaLeaf; +import static kubatech.api.enums.ItemList.YellowTea; +import static kubatech.api.enums.ItemList.YellowTeaLeaf; + +import java.lang.reflect.InvocationTargetException; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidRegistry; + +import com.dreammaster.gthandler.CustomItemList; + +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.core.lib.CORE; +import kubatech.api.LoaderReference; +import kubatech.api.enums.ItemList; +import kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_DEFusionCrafter; +import kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_ExtremeEntityCrusher; +import kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_ExtremeIndustrialGreenhouse; +import kubatech.tileentity.gregtech.multiblock.GT_MetaTileEntity_MegaIndustrialApiary; + +public class RecipeLoader { + + protected static final long bitsd = GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE + | GT_ModHandler.RecipeBits.BUFFERED + | GT_ModHandler.RecipeBits.DISMANTLEABLE; + + private static int MTEID = 14201; + private static final int MTEIDMax = 14300; + + public static void addRecipes() { + if (registerMTE( + ExtremeEntityCrusher, + GT_MetaTileEntity_ExtremeEntityCrusher.class, + "multimachine.entitycrusher", + "Extreme Entity Crusher", + LoaderReference.EnderIO)) { + GT_ModHandler.addCraftingRecipe( + ItemList.ExtremeEntityCrusher.get(1), + bitsd, + new Object[] { "RCR", "CHC", "VVV", 'R', gregtech.api.enums.ItemList.Robot_Arm_EV, 'C', + OrePrefixes.circuit.get(Materials.Data), 'H', gregtech.api.enums.ItemList.Hull_EV, 'V', + GT_ModHandler.getModItem("OpenBlocks", "vacuumhopper", 1, new ItemStack(Blocks.hopper)) }); + } + if (registerMTE( + ExtremeIndustrialApiary, + GT_MetaTileEntity_MegaIndustrialApiary.class, + "multimachine.extremeapiary", + "Industrial Apicultural Acclimatiser and Drone Domestication Station", + LoaderReference.Forestry)) { + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, gregtech.api.enums.ItemList.Machine_IndustrialApiary.get(1)) + .metadata(RESEARCH_TIME, 8 * MINUTES + 20 * SECONDS) + .itemInputs( + gregtech.api.enums.ItemList.Machine_IndustrialApiary.get(64L), + gregtech.api.enums.ItemList.IndustrialApiary_Upgrade_Acceleration_8_Upgraded.get(64L), + gregtech.api.enums.ItemList.IndustrialApiary_Upgrade_STABILIZER.get(64L), + gregtech.api.enums.ItemList.Robot_Arm_UV.get(16L), + new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 4L }, + new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 4L }, + new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 4L }, + new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 4L }) + .fluidInputs( + FluidRegistry.getFluidStack("molten.indalloy140", 28800), + FluidRegistry.getFluidStack("for.honey", 20000)) + .itemOutputs(ExtremeIndustrialApiary.get(1)) + .eut(2_048_000) + .duration(5 * MINUTES) + .addTo(AssemblyLine); + } + if (registerMTEUsingID( + 12_792, + ExtremeIndustrialGreenhouse, + GT_MetaTileEntity_ExtremeIndustrialGreenhouse.class, + "multimachine.extremegreenhouse", + "Extreme Industrial Greenhouse", + true /* IC2 is always loaded */)) { + GT_ModHandler.addCraftingRecipe( + ExtremeIndustrialGreenhouse.get(1), + bitsd, + new Object[] { "AZA", "BRB", "AZA", 'B', gregtech.api.enums.ItemList.Casing_CleanStainlessSteel, 'R', + GT_ModHandler.getModItem("EnderIO", "blockFarmStation", 1, new ItemStack(Items.diamond_hoe)), 'A', + LoaderReference.GTNHCoreMod ? CustomItemList.AcceleratorIV.get(1) + : gregtech.api.enums.ItemList.Robot_Arm_IV, + 'Z', OrePrefixes.circuit.get(Materials.Ultimate) }); + } + if (registerMTEUsingID( + 5_001, + DraconicEvolutionFusionCrafter, + GT_MetaTileEntity_DEFusionCrafter.class, + "multimachine.defusioncrafter", + "Draconic Evolution Fusion Crafter", + LoaderReference.DraconicEvolution)) { + // Controller recipe added in TecTech + DEFCRecipes.addRecipes(); + } + RegisterTeaLine(); + if (MTEID > MTEIDMax + 1) throw new RuntimeException("MTE ID's"); + } + + private static boolean registerMTE(ItemList item, Class mte, String aName, + String aNameRegional, boolean... deps) { + if (MTEID > MTEIDMax) throw new RuntimeException("MTE ID's"); + boolean dep = registerMTEUsingID(MTEID, item, mte, aName, aNameRegional, deps); + MTEID++; + return dep; + } + + private static boolean registerMTEUsingID(int ID, ItemList item, Class mte, String aName, + String aNameRegional, boolean... deps) { + boolean dep = true; + for (boolean b : deps) { + if (!b) { + dep = false; + break; + } + } + if (dep) { + try { + item.set( + mte.getConstructor(int.class, String.class, String.class) + .newInstance(ID, aName, aNameRegional) + .getStackForm(1)); + } catch (InvocationTargetException ex) { + Throwable original_ex = ex.getCause(); + if (original_ex instanceof RuntimeException) throw (RuntimeException) original_ex; + throw new RuntimeException(original_ex.getMessage()); + } catch (RuntimeException ex) { + throw ex; + } catch (Exception ex) { + throw new RuntimeException(ex.getMessage()); + } + } + return dep; + } + + private static boolean lateRecipesInitialized = false; + + public static void addRecipesLate() { + // Runs on server start + if (lateRecipesInitialized) return; + lateRecipesInitialized = true; + } + + private static void RegisterTeaLine() { + // TEA LINE // + if (LoaderReference.GTPlusPlus && LoaderReference.HarvestCraft) { + CORE.RA.addDehydratorRecipe( + new ItemStack[] { GameRegistry.findItemStack("harvestcraft", "tealeafItem", 1) }, + null, + null, + new ItemStack[] { TeaLeafDehydrated.get(1) }, + null, + 100, + 32); + CORE.RA.addDehydratorRecipe( + new ItemStack[] { TeaLeafDehydrated.get(1) }, + null, + null, + new ItemStack[] { WhiteTeaLeaf.get(1) }, + null, + 100, + 32); + GT_Values.RA.stdBuilder() + .itemInputs(TeaLeafDehydrated.get(1)) + .itemOutputs(SteamedTeaLeaf.get(1)) + .fluidInputs(FluidRegistry.getFluidStack("water", 50)) + .eut(32) + .duration(5 * SECONDS) + .addTo(mixerRecipes); + CORE.RA.addDehydratorRecipe( + new ItemStack[] { SteamedTeaLeaf.get(1) }, + null, + null, + new ItemStack[] { YellowTeaLeaf.get(1) }, + null, + 100, + 32); + GT_Values.RA.stdBuilder() + .itemInputs(TeaLeafDehydrated.get(1), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(RolledTeaLeaf.get(1)) + .eut(32) + .duration(5 * SECONDS) + .addTo(benderRecipes); + CORE.RA.addDehydratorRecipe( + new ItemStack[] { RolledTeaLeaf.get(1) }, + null, + null, + new ItemStack[] { GreenTeaLeaf.get(1) }, + null, + 100, + 32); + GT_Values.RA.stdBuilder() + .itemInputs(RolledTeaLeaf.get(1), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(OxidizedTeaLeaf.get(1)) + .eut(32) + .duration(5 * SECONDS) + .addTo(UniversalChemical); + CORE.RA.addDehydratorRecipe( + new ItemStack[] { OxidizedTeaLeaf.get(1) }, + null, + null, + new ItemStack[] { BlackTeaLeaf.get(1) }, + null, + 100, + 32); + GT_Values.RA.stdBuilder() + .itemInputs(RolledTeaLeaf.get(1), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(FermentedTeaLeaf.get(1)) + .eut(32) + .duration(10 * SECONDS) + .addTo(UniversalChemical); + CORE.RA.addDehydratorRecipe( + new ItemStack[] { FermentedTeaLeaf.get(1) }, + null, + null, + new ItemStack[] { PuerhTeaLeaf.get(1) }, + null, + 100, + 32); + GT_Values.RA.stdBuilder() + .itemInputs(TeaLeafDehydrated.get(1)) + .itemOutputs(BruisedTeaLeaf.get(1)) + .eut(32) + .duration(5 * SECONDS) + .addTo(cutterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(BruisedTeaLeaf.get(1), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(PartiallyOxidizedTeaLeaf.get(1)) + .eut(32) + .duration(2 * SECONDS + 10 * TICKS) + .addTo(UniversalChemical); + CORE.RA.addDehydratorRecipe( + new ItemStack[] { PartiallyOxidizedTeaLeaf.get(1) }, + null, + null, + new ItemStack[] { OolongTeaLeaf.get(1) }, + null, + 100, + 32); + + // Tea Assembly + GameRegistry.addSmelting(BlackTeaLeaf.get(1), BlackTea.get(1), 10); + GT_Values.RA.stdBuilder() + .itemInputs(BlackTea.get(1), GameRegistry.findItemStack("harvestcraft", "limejuiceItem", 1)) + .itemOutputs(EarlGrayTea.get(1)) + .eut(32) + .duration(5 * SECONDS) + .addTo(mixerRecipes); + GameRegistry.addSmelting(GreenTeaLeaf.get(1), GreenTea.get(1), 10); + GT_Values.RA.stdBuilder() + .itemInputs(BlackTea.get(1)) + .itemOutputs(LemonTea.get(1)) + .fluidInputs(FluidRegistry.getFluidStack("potion.lemonjuice", 1000)) + .eut(32) + .duration(5 * SECONDS) + .addTo(mixerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(BlackTea.get(1)) + .itemOutputs(MilkTea.get(1)) + .fluidInputs(FluidRegistry.getFluidStack("milk", 1000)) + .eut(32) + .duration(5 * SECONDS) + .addTo(mixerRecipes); + GameRegistry.addSmelting(OolongTeaLeaf.get(1), OolongTea.get(1), 10); + GT_Values.RA.stdBuilder() + .itemInputs(GameRegistry.findItemStack("harvestcraft", "peppermintItem", 1)) + .itemOutputs(PeppermintTea.get(1)) + .fluidInputs(FluidRegistry.getFluidStack("water", 1000)) + .eut(32) + .duration(5 * SECONDS) + .addTo(mixerRecipes); + GameRegistry.addSmelting(PuerhTeaLeaf.get(1), PuerhTea.get(1), 10); + GameRegistry.addSmelting(WhiteTeaLeaf.get(1), WhiteTea.get(1), 10); + GameRegistry.addSmelting(YellowTeaLeaf.get(1), YellowTea.get(1), 10); + } + if (LoaderReference.Avaritia && LoaderReference.GTNHCoreMod) { + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, TeaAcceptorResearchNote.get(1)) + .metadata(RESEARCH_TIME, 8 * MINUTES + 20 * SECONDS) + .itemInputs( + LegendaryUltimateTea.get(0), + GameRegistry.findItemStack("Avaritia", "Neutronium_Compressor", 1), + gregtech.api.enums.ItemList.Quantum_Tank_EV.get(1), + CustomItemList.FluidExtractorUHV.get(10), + new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 4L }, + new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 4L }, + new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 4L }, + new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 4L }) + .fluidInputs(FluidRegistry.getFluidStack("molten.indalloy140", 28800)) + .itemOutputs(TeaAcceptor.get(1)) + .eut(2_048_000) + .duration(5 * MINUTES) + .addTo(AssemblyLine); + } + } +} diff --git a/src/main/java/kubatech/loaders/TCLoader.java b/src/main/java/kubatech/loaders/TCLoader.java new file mode 100644 index 0000000000..7d6abe5132 --- /dev/null +++ b/src/main/java/kubatech/loaders/TCLoader.java @@ -0,0 +1,151 @@ +/* + * spotless:off + * KubaTech - Gregtech Addon + * Copyright (C) 2022 - 2024 kuba6000 + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +