diff options
Diffstat (limited to 'src/main/java/gregtech/common')
4 files changed, 1134 insertions, 0 deletions
diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java index ed54ccf91e..cde7a66229 100644 --- a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java +++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java @@ -48,12 +48,35 @@ import static gregtech.client.GT_TooltipHandler.Tier.LV; import static gregtech.client.GT_TooltipHandler.Tier.LuV; import static gregtech.client.GT_TooltipHandler.Tier.MAX; import static gregtech.client.GT_TooltipHandler.Tier.MV; +import static gregtech.client.GT_TooltipHandler.Tier.UEV; +import static gregtech.client.GT_TooltipHandler.Tier.UHV; +import static gregtech.client.GT_TooltipHandler.Tier.UIV; import static gregtech.client.GT_TooltipHandler.Tier.ULV; import static gregtech.client.GT_TooltipHandler.Tier.UMV; import static gregtech.client.GT_TooltipHandler.Tier.UV; import static gregtech.client.GT_TooltipHandler.Tier.UXV; import static gregtech.client.GT_TooltipHandler.Tier.ZPM; import static gregtech.client.GT_TooltipHandler.registerTieredTooltip; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_EV; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_EV_Full; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_IV; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_IV_Full; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_LuV; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_LuV_Full; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_UEV; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_UEV_Full; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_UHV; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_UHV_Full; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_UIV; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_UIV_Full; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_UMV; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_UMV_Full; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_UV; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_UV_Full; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_UxV; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_UxV_Full; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_ZPM; +import static gregtech.common.items.ID_MetaItem_01.BatteryHull_ZPM_Full; import static gregtech.common.items.ID_MetaItem_01.Battery_Hull_HV; import static gregtech.common.items.ID_MetaItem_01.Battery_Hull_LV; import static gregtech.common.items.ID_MetaItem_01.Battery_Hull_MV; @@ -3120,6 +3143,199 @@ public class GT_MetaGenerated_Item_01 extends GT_MetaGenerated_Item_X32 { EnumChatFormatting.GREEN + "Tengam Electromagnet", MagnetTiers.buildMagnetTooltip(MagnetTiers.Tengam), new TC_Aspects.TC_AspectStack(TC_Aspects.MAGNETO, 40))); + + // Empty battery hulls + ItemList.BatteryHull_EV.set( + addItem( + BatteryHull_EV.ID, + "Small Sunnarium Battery (Empty)", + "An empty EV Battery Container", + new ItemData(Materials.BlueSteel, OrePrefixes.plate.mMaterialAmount * 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 8L))); + ItemList.BatteryHull_IV.set( + addItem( + BatteryHull_IV.ID, + "Medium Sunnarium Battery (Empty)", + "An empty IV Battery Container", + new ItemData(Materials.RoseGold, OrePrefixes.plate.mMaterialAmount * 6L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 16L))); + ItemList.BatteryHull_LuV.set( + addItem( + BatteryHull_LuV.ID, + "Large Sunnarium Battery (Empty)", + "An empty LuV Battery Container", + new ItemData(Materials.RedSteel, OrePrefixes.plate.mMaterialAmount * 18L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 32L))); + ItemList.BatteryHull_ZPM.set( + addItem( + BatteryHull_ZPM.ID, + "Medium Naquadria Battery (Empty)", + "An empty ZPM Energy Storage", + new ItemData(Materials.Europium, OrePrefixes.plate.mMaterialAmount * 6L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 64L))); + ItemList.BatteryHull_UV.set( + addItem( + BatteryHull_UV.ID, + "Large Naquadria Battery (Empty)", + "An empty UV Energy Storage", + new ItemData(Materials.Americium, OrePrefixes.plate.mMaterialAmount * 18L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 128L))); + ItemList.BatteryHull_UHV.set( + addItem( + BatteryHull_UHV.ID, + "Small Neutronium Battery (Empty)", + "An empty UHV Energy Storage", + new ItemData(Materials.Naquadah, OrePrefixes.plate.mMaterialAmount * 24L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 256L))); + ItemList.BatteryHull_UEV.set( + addItem( + BatteryHull_UEV.ID, + "Medium Neutronium Battery (Empty)", + "An empty UEV Energy Storage", + new ItemData(Materials.NaquadahEnriched, OrePrefixes.plate.mMaterialAmount * 36L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 512L))); + ItemList.BatteryHull_UIV.set( + addItem( + BatteryHull_UIV.ID, + "Large Neutronium Battery (Empty)", + "An empty UIV Energy Storage", + new ItemData(Materials.NaquadahAlloy, OrePrefixes.plate.mMaterialAmount * 48L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1024L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 1024L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1024L))); + ItemList.BatteryHull_UMV.set( + addItem( + BatteryHull_UMV.ID, + "Medium Plasma Battery (Empty)", + "An empty UMV Energy Storage", + new ItemData(Materials.Neutronium, OrePrefixes.plate.mMaterialAmount * 56L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2048L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 2048L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 2048L))); + ItemList.BatteryHull_UxV.set( + addItem( + BatteryHull_UxV.ID, + "Large Plasma Battery (Empty)", + "An empty UXV Energy Storage", + new ItemData(Materials.DraconiumAwakened, OrePrefixes.plate.mMaterialAmount * 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4096L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 4096L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 4096L))); + + ItemList.BatteryHull_EV_Full.set( + addItem( + BatteryHull_EV_Full.ID, + "Small Sunnarium Battery", + "Reusable", + "batteryEV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 32L))); + + ItemList.BatteryHull_IV_Full.set( + addItem( + BatteryHull_IV_Full.ID, + "Medium Sunnarium Battery", + "Reusable", + "batteryIV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 32L))); + + ItemList.BatteryHull_LuV_Full.set( + addItem( + BatteryHull_LuV_Full.ID, + "Large Sunnarium Battery", + "Reusable", + "batteryLuV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 32L))); + + ItemList.BatteryHull_ZPM_Full.set( + addItem( + BatteryHull_ZPM_Full.ID, + "Medium Naquadria Battery", + "Reusable", + "batteryZPM", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 32L))); + + ItemList.BatteryHull_UV_Full.set( + addItem( + BatteryHull_UV_Full.ID, + "Large Naquadria Battery", + "Reusable", + "batteryUV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 32L))); + + ItemList.BatteryHull_UHV_Full.set( + addItem( + BatteryHull_UHV_Full.ID, + "Small Neutronium Battery", + "Reusable", + "batteryUHV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 32L))); + + ItemList.BatteryHull_UEV_Full.set( + addItem( + BatteryHull_UEV_Full.ID, + "Medium Neutronium Battery", + "Reusable", + "batteryUEV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 32L))); + + ItemList.BatteryHull_UIV_Full.set( + addItem( + BatteryHull_UIV_Full.ID, + "Large Neutronium Battery", + "Reusable", + "batteryUIV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 32L))); + + ItemList.BatteryHull_UMV_Full.set( + addItem( + BatteryHull_UMV_Full.ID, + "Medium Infinity Battery", + "Reusable", + "batteryUMV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 32L))); + + ItemList.BatteryHull_UxV_Full.set( + addItem( + BatteryHull_UxV_Full.ID, + "Large Infinity Battery", + "Reusable", + "batteryUXV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 32L))); + removeRecipes(); setBurnValues(); oredictBlacklistEntries(); @@ -4054,6 +4270,106 @@ public class GT_MetaGenerated_Item_01 extends GT_MetaGenerated_Item_X32 { .duration(5 * SECONDS) .eut(TierEU.RECIPE_LV) .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Aluminium, 2L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.BlueSteel, 2L)) + .itemOutputs(ItemList.BatteryHull_EV.get(1L)) + .fluidInputs(Materials.Polytetrafluoroethylene.getMolten(144L)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Platinum, 2L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.RoseGold, 6L)) + .itemOutputs(ItemList.BatteryHull_IV.get(1L)) + .fluidInputs(Materials.Polytetrafluoroethylene.getMolten(288L)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Naquadah, 2L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.RedSteel, 18L)) + .itemOutputs(ItemList.BatteryHull_LuV.get(1L)) + .fluidInputs(Materials.Polybenzimidazole.getMolten(144L)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.NaquadahAlloy, 2L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Europium, 6L)) + .itemOutputs(ItemList.BatteryHull_ZPM.get(1L)) + .fluidInputs(Materials.Polybenzimidazole.getMolten(288L)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.ElectrumFlux, 2L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Americium, 18L)) + .itemOutputs(ItemList.BatteryHull_UV.get(1L)) + .fluidInputs(Materials.Polybenzimidazole.getMolten(576L)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.cableGt02, Materials.ElectrumFlux, 2L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Naquadah, 24L)) + .itemOutputs(ItemList.BatteryHull_UHV.get(1L)) + .fluidInputs(Materials.Polybenzimidazole.getMolten(1152L)) + .duration(5 * SECONDS) + .eut(500000) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.ElectrumFlux, 2L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NaquadahEnriched, 36L)) + .itemOutputs(ItemList.BatteryHull_UEV.get(1L)) + .fluidInputs(Materials.Polybenzimidazole.getMolten(2304L)) + .duration(10 * SECONDS) + .eut(2000000) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.cableGt08, Materials.ElectrumFlux, 2L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.NaquadahAlloy, 48L)) + .itemOutputs(ItemList.BatteryHull_UIV.get(1L)) + .fluidInputs(Materials.Polybenzimidazole.getMolten(4608L)) + .duration(15 * SECONDS) + .eut(2000000) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.wireGt16, Materials.SuperconductorUHV, 2L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Neutronium, 56L)) + .itemOutputs(ItemList.BatteryHull_UMV.get(1L)) + .fluidInputs(Materials.Polybenzimidazole.getMolten(9216L)) + .duration(30 * SECONDS) + .eut(2000000) + .addTo(assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.wireGt16, Materials.SuperconductorUHV, 2L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.DraconiumAwakened, 64L)) + .itemOutputs(ItemList.BatteryHull_UxV.get(1L)) + .fluidInputs(Materials.Polybenzimidazole.getMolten(18432L)) + .duration(60 * SECONDS) + .eut(2000000) + .addTo(assemblerRecipes); } private void cannerRecipes() { @@ -4129,6 +4445,107 @@ public class GT_MetaGenerated_Item_01 extends GT_MetaGenerated_Item_X32 { .duration(1 * MINUTES + 20 * SECONDS) .eut(2) .addTo(cannerRecipes); + // Recipes to actually fill the empty hulls with content + // IV 2048 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sunnarium, 4L), + ItemList.BatteryHull_EV.get(1L)) + .itemOutputs(ItemList.BatteryHull_EV_Full.get(1L)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(cannerRecipes); + // EV 8192 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sunnarium, 16L), + ItemList.BatteryHull_IV.get(1L)) + .itemOutputs(ItemList.BatteryHull_IV_Full.get(1L)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(1024) + .addTo(cannerRecipes); + // LuV 32768 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sunnarium, 32L), + ItemList.BatteryHull_LuV.get(1L)) + .itemOutputs(ItemList.BatteryHull_LuV_Full.get(1L)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(cannerRecipes); + // ZPM 131072 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 16L), + ItemList.BatteryHull_ZPM.get(1L)) + .itemOutputs(ItemList.BatteryHull_ZPM_Full.get(1L)) + .duration(12 * SECONDS + 10 * TICKS) + .eut(4096) + .addTo(cannerRecipes); + // UV 524288 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 32L), + ItemList.BatteryHull_UV.get(1L)) + .itemOutputs(ItemList.BatteryHull_UV_Full.get(1L)) + .duration(15 * SECONDS) + .eut(7860) + .addTo(cannerRecipes); + // UHV 2097152 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Neutronium, 16L), + ItemList.BatteryHull_UHV.get(1L)) + .itemOutputs(ItemList.BatteryHull_UHV_Full.get(1L)) + .duration(17 * SECONDS + 10 * TICKS) + .eut(15720) + .addTo(cannerRecipes); + // UEV 8388608 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Neutronium, 32L), + ItemList.BatteryHull_UEV.get(1L)) + .itemOutputs(ItemList.BatteryHull_UEV_Full.get(1L)) + .duration(20 * SECONDS) + .eut(31440) + .addTo(cannerRecipes); + // UIV 33554432 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Neutronium, 64L), + ItemList.BatteryHull_UIV.get(1L)) + .itemOutputs(ItemList.BatteryHull_UIV_Full.get(1L)) + .duration(22 * SECONDS + 10 * TICKS) + .eut(62880) + .addTo(cannerRecipes); + // UMV 134217728 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Infinity, 4L), + ItemList.BatteryHull_UMV.get(1L)) + .itemOutputs(ItemList.BatteryHull_UMV_Full.get(1L)) + .duration(25 * SECONDS) + .eut(125760) + .addTo(cannerRecipes); + // UxV 536870912 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Infinity, 8L), + ItemList.BatteryHull_UxV.get(1L)) + .itemOutputs(ItemList.BatteryHull_UxV_Full.get(1L)) + .duration(30 * SECONDS) + .eut(251520) + .addTo(cannerRecipes); } private void packagerRecipes() { @@ -4239,6 +4656,67 @@ public class GT_MetaGenerated_Item_01 extends GT_MetaGenerated_Item_X32 { .duration(15 * SECONDS) .eut(2) .addTo(extractorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.BatteryHull_EV_Full.get(1L)) + .itemOutputs(ItemList.BatteryHull_EV.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(extractorRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.BatteryHull_IV_Full.get(1L)) + .itemOutputs(ItemList.BatteryHull_IV.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(extractorRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.BatteryHull_LuV_Full.get(1L)) + .itemOutputs(ItemList.BatteryHull_LuV.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(extractorRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.BatteryHull_ZPM_Full.get(1L)) + .itemOutputs(ItemList.BatteryHull_ZPM.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(extractorRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.BatteryHull_UV_Full.get(1L)) + .itemOutputs(ItemList.BatteryHull_UV.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(extractorRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.BatteryHull_UHV_Full.get(1L)) + .itemOutputs(ItemList.BatteryHull_UHV.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(extractorRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.BatteryHull_UEV_Full.get(1L)) + .itemOutputs(ItemList.BatteryHull_UEV.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(extractorRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.BatteryHull_UIV_Full.get(1L)) + .itemOutputs(ItemList.BatteryHull_UIV.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(extractorRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.BatteryHull_UMV_Full.get(1L)) + .itemOutputs(ItemList.BatteryHull_UMV.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(extractorRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.BatteryHull_UxV_Full.get(1L)) + .itemOutputs(ItemList.BatteryHull_UxV.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(extractorRecipes); } private void craftingShapedRecipes() { @@ -4884,6 +5362,16 @@ public class GT_MetaGenerated_Item_01 extends GT_MetaGenerated_Item_X32 { setElectricStats(32000 + Tool_Cover_Copy_Paste.ID, 400000L, GT_Values.V[2], 2L, -1L, false); setElectricStats(32000 + Tool_Cheat.ID, -2000000000L, 1000000000L, -1L, -3L, false); setElectricStats(32000 + Tool_Scanner.ID, 400000L, GT_Values.V[2], 2L, -1L, false); + setElectricStats(32000 + BatteryHull_EV_Full.ID, 6400000L, GT_Values.V[4], 4L, -3L, true); + setElectricStats(32000 + BatteryHull_IV_Full.ID, 25600000L, GT_Values.V[5], 5L, -3L, true); + setElectricStats(32000 + BatteryHull_LuV_Full.ID, 102400000L, GT_Values.V[6], 6L, -3L, true); + setElectricStats(32000 + BatteryHull_ZPM_Full.ID, 409600000L, GT_Values.V[7], 7L, -3L, true); + setElectricStats(32000 + BatteryHull_UV_Full.ID, 1638400000L, GT_Values.V[8], 8L, -3L, true); + setElectricStats(32000 + BatteryHull_UHV_Full.ID, 6553600000L, GT_Values.V[9], 9L, -3L, true); + setElectricStats(32000 + BatteryHull_UEV_Full.ID, 26214400000L, GT_Values.V[10], 10L, -3L, true); + setElectricStats(32000 + BatteryHull_UIV_Full.ID, 104857600000L, GT_Values.V[11], 11L, -3L, true); + setElectricStats(32000 + BatteryHull_UMV_Full.ID, 419430400000L, GT_Values.V[12], 12L, -3L, true); + setElectricStats(32000 + BatteryHull_UxV_Full.ID, 1677721600000L, GT_Values.V[13], 13L, -3L, true); } private void registerTieredTooltips() { @@ -4920,6 +5408,16 @@ public class GT_MetaGenerated_Item_01 extends GT_MetaGenerated_Item_X32 { registerTieredTooltip(ItemList.Circuit_Data.get(1), EV); registerTieredTooltip(ItemList.Circuit_Elite.get(1), IV); registerTieredTooltip(ItemList.Circuit_Master.get(1), LuV); + registerTieredTooltip(ItemList.BatteryHull_EV_Full.get(1), EV); + registerTieredTooltip(ItemList.BatteryHull_IV_Full.get(1), IV); + registerTieredTooltip(ItemList.BatteryHull_LuV_Full.get(1), LuV); + registerTieredTooltip(ItemList.BatteryHull_ZPM_Full.get(1), ZPM); + registerTieredTooltip(ItemList.BatteryHull_UV_Full.get(1), UV); + registerTieredTooltip(ItemList.BatteryHull_UHV_Full.get(1), UHV); + registerTieredTooltip(ItemList.BatteryHull_UEV_Full.get(1), UEV); + registerTieredTooltip(ItemList.BatteryHull_UIV_Full.get(1), UIV); + registerTieredTooltip(ItemList.BatteryHull_UMV_Full.get(1), UMV); + registerTieredTooltip(ItemList.BatteryHull_UxV_Full.get(1), UXV); } } diff --git a/src/main/java/gregtech/common/items/ID_MetaItem_01.java b/src/main/java/gregtech/common/items/ID_MetaItem_01.java index fd6f1cc78d..308b154aae 100644 --- a/src/main/java/gregtech/common/items/ID_MetaItem_01.java +++ b/src/main/java/gregtech/common/items/ID_MetaItem_01.java @@ -219,6 +219,11 @@ public enum ID_MetaItem_01 { Battery_Hull_LV(500), Battery_Hull_MV(501), Battery_Hull_HV(502), + BatteryHull_EV(503), + BatteryHull_IV(504), + BatteryHull_LuV(505), + BatteryHull_ZPM(506), + BatteryHull_UV(507), Battery_SU_LV_Sulfuric_Acid(510), Battery_SU_LV_Mercury(511), Battery_RE_LV_Cadmium(517), @@ -234,7 +239,22 @@ public enum ID_MetaItem_01 { Battery_RE_HV_Cadmium(537), Battery_RE_HV_Lithium(538), Battery_RE_HV_Sodium(539), + BatteryHull_EV_Full(540), + BatteryHull_IV_Full(545), + BatteryHull_LuV_Full(550), + BatteryHull_ZPM_Full(555), + BatteryHull_UV_Full(560), + BatteryHull_UHV(561), + BatteryHull_UEV(562), + BatteryHull_UIV(563), + BatteryHull_UMV(564), + BatteryHull_UxV(565), + BatteryHull_UHV_Full(570), + BatteryHull_UEV_Full(575), Cover_FLuidStorageMonitor(577), + BatteryHull_UIV_Full(580), + BatteryHull_UMV_Full(585), + BatteryHull_UxV_Full(590), ZPM4(594), Electric_Motor_UEV(595), Electric_Motor_UHV(596), diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_TurboCharger.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_TurboCharger.java new file mode 100644 index 0000000000..a098e635f0 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_TurboCharger.java @@ -0,0 +1,146 @@ +package gregtech.common.tileentities.machines.basic; + +import static gregtech.api.enums.GT_Values.V; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.BaseMetaTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Utility; + +/** + * Created by danie_000 on 15.10.2016. + */ +public class GT_MetaTileEntity_TurboCharger extends GT_MetaTileEntity_Charger { + + public GT_MetaTileEntity_TurboCharger(int aID, String aName, String aNameRegional, int aTier, String aDescription, + int aSlotCount) { + super(aID, aName, aNameRegional, aTier, aDescription, aSlotCount); + } + + public GT_MetaTileEntity_TurboCharger(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures, + int aSlotCount) { + super(aName, aTier, aDescription, aTextures, aSlotCount); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_TurboCharger(mName, mTier, mDescriptionArray, mTextures, mInventory.length); + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] aTextures) { + ITexture[][][] rTextures = new ITexture[2][17][]; + for (byte b = -1; b < 16; b++) { + rTextures[0][b + 1] = new ITexture[] { Textures.BlockIcons.MACHINE_CASINGS[mTier][b + 1] }; + rTextures[1][b + 1] = new ITexture[] { Textures.BlockIcons.MACHINE_CASINGS[mTier][b + 1], + Textures.BlockIcons.OVERLAYS_ENERGY_OUT_POWER[mTier] }; + } + return rTextures; + } + + @Override + public long getMinimumStoredEU() { + return V[mTier] * 1536L * mInventory.length; + } + + @Override + public long maxEUStore() { + return V[mTier] * 6144L * mInventory.length; + } + + @Override + public long maxAmperesIn() { + return 16L * mInventory.length; + } + + @Override + public long maxAmperesOut() { + return 4L * mInventory.length; + } + + @Override + public long maxEUInput() { + return V[mTier]; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide()) { + + mCharge = aBaseMetaTileEntity.getStoredEU() / 2 > aBaseMetaTileEntity.getEUCapacity() / 3 + || !aBaseMetaTileEntity.isAllowedToWork(); + mDecharge = aBaseMetaTileEntity.getStoredEU() < aBaseMetaTileEntity.getEUCapacity() / 3 + && aBaseMetaTileEntity.isAllowedToWork(); + mBatteryCount = 0; + mChargeableCount = 0; + for (ItemStack tStack : mInventory) { + if (GT_ModHandler.isElectricItem(tStack, mTier)) { + if (GT_ModHandler.isChargerItem(tStack)) { + mBatteryCount++; + } + mChargeableCount++; + } + } + + if (getBaseMetaTileEntity() instanceof BaseMetaTileEntity) { + BaseMetaTileEntity mBaseMetaTileEntity = (BaseMetaTileEntity) getBaseMetaTileEntity(); + if (mBaseMetaTileEntity.getMetaTileEntity() instanceof MetaTileEntity) { + MetaTileEntity mMetaTileEntity = (MetaTileEntity) mBaseMetaTileEntity.getMetaTileEntity(); + if (mMetaTileEntity.dechargerSlotCount() > 0 + && mBaseMetaTileEntity.getStoredEU() < mBaseMetaTileEntity.getEUCapacity()) { + for (int i = mMetaTileEntity.dechargerSlotStartIndex(), + k = mMetaTileEntity.dechargerSlotCount() + i; i < k; i++) { + if (mMetaTileEntity.mInventory[i] != null + && mBaseMetaTileEntity.getStoredEU() < mBaseMetaTileEntity.getEUCapacity()) { + // CODE + mBaseMetaTileEntity.increaseStoredEnergyUnits( + GT_ModHandler.dischargeElectricItem( + mMetaTileEntity.mInventory[i], + GT_Utility.safeInt( + Math.min( + V[mTier] * 120, + mBaseMetaTileEntity.getEUCapacity() + - mBaseMetaTileEntity.getStoredEU())), + (int) Math.min(Integer.MAX_VALUE, mMetaTileEntity.getInputTier()), + true, + false, + false), + true); + if (mMetaTileEntity.mInventory[i].stackSize <= 0) { + mMetaTileEntity.mInventory[i] = null; + } + } + } + } + if (mMetaTileEntity.rechargerSlotCount() > 0 && mBaseMetaTileEntity.getStoredEU() > 0) { + for (int i = mMetaTileEntity.rechargerSlotStartIndex(), + k = mMetaTileEntity.rechargerSlotCount() + i; i < k; i++) { + if (mBaseMetaTileEntity.getStoredEU() > 0 && mMetaTileEntity.mInventory[i] != null) { + // CODE + mBaseMetaTileEntity + .decreaseStoredEU( + GT_ModHandler.chargeElectricItem( + mMetaTileEntity.mInventory[i], + GT_Utility + .safeInt(Math.min(V[mTier] * 120, mBaseMetaTileEntity.getStoredEU())), + (int) Math.min(Integer.MAX_VALUE, mMetaTileEntity.getOutputTier()), + true, + false), + true); + if (mMetaTileEntity.mInventory[i].stackSize <= 0) { + mMetaTileEntity.mInventory[i] = null; + } + } + } + } + } + } + } + } +} diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_WorldAccelerator.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_WorldAccelerator.java new file mode 100644 index 0000000000..1b0048f2ec --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_WorldAccelerator.java @@ -0,0 +1,470 @@ +package gregtech.common.tileentities.machines.basic; + +import static gregtech.api.enums.GT_Values.V; +import static gregtech.api.enums.Mods.GregTech; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import eu.usrv.yamcore.auxiliary.PlayerChatHelper; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_TieredMachineBlock; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_Log; + +public class GT_MetaTileEntity_WorldAccelerator extends GT_MetaTileEntity_TieredMachineBlock { + + // simple name is rather expensive to compute and it's not cached + // see https://stackoverflow.com/q/17369304 + private static final ClassValue<String> simpleNameCache = new ClassValue<String>() { + + @Override + protected String computeValue(Class<?> type) { + return type.getSimpleName(); + } + }; + private static final HashSet<Class<? extends TileEntity>> _mBlacklistedTiles = new HashSet<>(); + + public static boolean addTileToBlacklist(Class<? extends TileEntity> clazz) { + return _mBlacklistedTiles.add(clazz); + } + + public static boolean addTileToBlacklist(TileEntity tileEntity) { + return _mBlacklistedTiles.add(tileEntity.getClass()); + } + + public static HashSet<Class<? extends TileEntity>> get_mBlacklistedTiles() { + return _mBlacklistedTiles; + } + + private int _mRadiusTierOverride = -1; + private int _mSpeedTierOverride = -1; + + private int getRadiusTierOverride() { + if (_mRadiusTierOverride == -1) _mRadiusTierOverride = mTier; + return _mRadiusTierOverride; + } + + private int getSpeedTierOverride() { + if (_mSpeedTierOverride == -1) _mSpeedTierOverride = mTier; + return _mSpeedTierOverride; + } + + private int incSpeedTierOverride() { + _mSpeedTierOverride = getSpeedTierOverride() + 1; + if (_mSpeedTierOverride > mTier) _mSpeedTierOverride = 1; + + return _mSpeedTierOverride; + } + + private int incRadiusTierOverride() { + // Make sure we get the Override value first, as we check it for initial -1 + _mRadiusTierOverride = getRadiusTierOverride() + 1; + if (_mRadiusTierOverride > mTier) _mRadiusTierOverride = 1; + + return _mRadiusTierOverride; + } + + private byte mMode = 0; // 0: RandomTicks around 1: TileEntities with range 1 + private static Textures.BlockIcons.CustomIcon _mGTIco_Norm_Idle; + private static Textures.BlockIcons.CustomIcon _mGTIco_Norm_Active; + private static Textures.BlockIcons.CustomIcon _mGTIco_TE_Idle; + private static Textures.BlockIcons.CustomIcon _mGTIco_TE_Active; + private static int[] mAccelerateStatic = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 512, 512, 512, 512, 512, 512 }; + private static final int AMPERAGE_NORMAL = 3; + private static final int AMPERAGE_TE = 6; + + @Override + public void registerIcons(IIconRegister aBlockIconRegister) { + super.registerIcons(aBlockIconRegister); + _mGTIco_Norm_Idle = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_ACCELERATOR"); + _mGTIco_Norm_Active = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_ACCELERATOR_ACTIVE"); + _mGTIco_TE_Idle = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_ACCELERATOR_TE"); + _mGTIco_TE_Active = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_ACCELERATOR_TE_ACTIVE"); + } + + @SideOnly(Side.CLIENT) + @Override + public void onValueUpdate(byte aValue) { + mMode = aValue; + } + + @Override + public byte getUpdateData() { + return mMode; + } + + public GT_MetaTileEntity_WorldAccelerator(int pID, String pName, String pNameRegional, int pTier) { + super(pID, pName, pNameRegional, pTier, 0, ""); + } + + @Override + public String[] getDescription() { + return new String[] { + String + .format("Accelerating things (Max Radius: %d | Max Speed Bonus: x%d)", mTier, mAccelerateStatic[mTier]), + "Use a screwdriver to change mode, sneak to change Radius", "Use a wrench to change speed", + "To accelerate TileEntities, this machine has to be adjacent to it", + String.format("Normal mode consumes up to %s amperage, depending on radius", AMPERAGE_NORMAL), + String.format("TE mode consumes %s amperage", AMPERAGE_TE) }; + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public String[] getInfoData() { + List<String> tInfoDisplay = new ArrayList<>(); + + tInfoDisplay.add(String.format("Accelerator running in %s mode", mModeStr[mMode])); + tInfoDisplay.add( + String.format( + "Speed setting: [%d / %d]", + mAccelerateStatic[getSpeedTierOverride()], + mAccelerateStatic[mTier])); + tInfoDisplay.add( + String.format( + "Consuming %d EU/t", + getEnergyDemand(getSpeedTierOverride(), getRadiusTierOverride(), mMode == 1))); + + // Don't show radius setting if in TE Mode + if (mMode == 0) tInfoDisplay.add(String.format("Radius setting: [%d / %d]", getRadiusTierOverride(), mTier)); + + return tInfoDisplay.toArray(new String[0]); + } + + public GT_MetaTileEntity_WorldAccelerator(String pName, int pTier, int pInvSlotCount, String[] pDescription, + ITexture[][][] pTextures) { + super(pName, pTier, pInvSlotCount, pDescription, pTextures); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity pTileEntity) { + return new GT_MetaTileEntity_WorldAccelerator(mName, mTier, mInventory.length, mDescriptionArray, mTextures); + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] pTextures) { + return null; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity pBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing, + int colorIndex, boolean pActive, boolean pRedstone) { + if (mMode == 0) { + return new ITexture[] { Textures.BlockIcons.MACHINE_CASINGS[mTier][colorIndex + 1], side.offsetY != 0 ? null + : pActive ? new GT_RenderedTexture(_mGTIco_Norm_Active) : new GT_RenderedTexture(_mGTIco_Norm_Idle) }; + } else { + return new ITexture[] { Textures.BlockIcons.MACHINE_CASINGS[mTier][colorIndex + 1], side.offsetY != 0 ? null + : pActive ? new GT_RenderedTexture(_mGTIco_TE_Active) : new GT_RenderedTexture(_mGTIco_TE_Idle) }; + } + } + + @Override + public boolean allowPullStack(IGregTechTileEntity pBaseMetaTileEntity, int pIndex, ForgeDirection side, + ItemStack pStack) { + return false; + } + + @Override + public boolean allowPutStack(IGregTechTileEntity pBaseMetaTileEntity, int pIndex, ForgeDirection side, + ItemStack pStack) { + return false; + } + + @Override + public void saveNBTData(NBTTagCompound pNBT) { + pNBT.setByte("mAccelMode", mMode); + + // SpeedOverride can never be larger than mTier; Which will never exceed 255, so it's safe to cast here + pNBT.setByte("mSpeed", (byte) getSpeedTierOverride()); + pNBT.setByte("mRadius", (byte) getRadiusTierOverride()); + } + + public long getEnergyDemand(int pSpeedTier, int pRangeTier, boolean pIsAcceleratingTEs) { + // TE mode does not need to consider range setting + if (pIsAcceleratingTEs) return V[pSpeedTier] * AMPERAGE_TE; + + // Include range setting into power calculation + float multiplier = 100.0F / (float) mTier * (float) pRangeTier / 100.0F; + long demand = V[pSpeedTier] * AMPERAGE_NORMAL; + + float tDemand = demand * multiplier; + + return (int) tDemand; + } + + @Override + public void loadNBTData(NBTTagCompound pNBT) { + mMode = pNBT.getByte("mAccelMode"); + + // Make sure we're not crashing with old Accelerator Machines + if (pNBT.hasKey("mSpeed")) _mSpeedTierOverride = pNBT.getByte("mSpeed"); + if (pNBT.hasKey("mRadius")) _mRadiusTierOverride = pNBT.getByte("mRadius"); + } + + @Override + public boolean isAccessAllowed(EntityPlayer pPlayer) { + return true; + } + + @Override + public boolean isSimpleMachine() { + return false; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public boolean isEnetInput() { + return true; + } + + @Override + public boolean isInputFacing(ForgeDirection side) { + return true; + } + + @Override + public boolean isTeleporterCompatible() { + return false; + } + + @Override + public long getMinimumStoredEU() { + return 512; + } + + @Override + public long maxEUStore() { + return 512 + V[mTier] * 50; + } + + @Override + public long maxEUInput() { + return V[mTier]; + } + + @Override + public long maxAmperesIn() { + return 8; + } + + private static String[] mModeStr = { "Blocks", "TileEntities" }; + + // This uses the Wrench as second tool to cycle speeds + @Override + public boolean onWrenchRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer pPlayer, float aX, + float aY, float aZ) { + incSpeedTierOverride(); + + markDirty(); + PlayerChatHelper.SendInfo( + pPlayer, + String.format("Machine acceleration changed to x%d", mAccelerateStatic[getSpeedTierOverride()])); + + return true; + } + + @Override + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer pPlayer, float pX, float pY, float pZ) { + if (pPlayer.isSneaking()) { + if (mMode == 0) { + incRadiusTierOverride(); + + markDirty(); + PlayerChatHelper + .SendInfo(pPlayer, String.format("Machine radius changed to %d Blocks", getRadiusTierOverride())); + } else PlayerChatHelper + .SendError(pPlayer, String.format("Can't change radius; Machine is in TileEntity Mode!")); + } else { + mMode = (byte) (mMode == 0x00 ? 0x01 : 0x00); + markDirty(); + PlayerChatHelper.SendInfo(pPlayer, String.format("Switched mode to: %s", mModeStr[mMode])); + } + } + + @Override + public void onPostTick(IGregTechTileEntity pBaseMetaTileEntity, long pTick) { + try { + if (!pBaseMetaTileEntity.isServerSide()) { + return; + } + + long tEnergyDemand = getEnergyDemand(getSpeedTierOverride(), getRadiusTierOverride(), mMode == 1); + + // Do we have enough energy to run? Or are we not allowed to run? + if (pBaseMetaTileEntity.getStoredEU() < tEnergyDemand || !pBaseMetaTileEntity.isAllowedToWork()) { + // Check if machine was active before + if (pBaseMetaTileEntity.isActive()) { + pBaseMetaTileEntity.setActive(false); // Then disable it now + } + } else { + // Continue to drain power + if (pBaseMetaTileEntity.decreaseStoredEnergyUnits(tEnergyDemand, false)) { + World tWorld = pBaseMetaTileEntity.getWorld(); + // Limit the random ticks to once per second + if (mMode == 0) { + if (pTick % 20 == 0) { + doAccelerateNormalBlocks(pBaseMetaTileEntity, tWorld); + } + } else { + doAccelerateTileEntities(pBaseMetaTileEntity, tWorld); + } + + } else { + // Energy drain failed. Disable machine + if (pBaseMetaTileEntity.isActive()) { + pBaseMetaTileEntity.setActive(false); // Then disable it now + } + } + } + } catch (Exception e) { + GT_Log.err.println("GT_MetaTileEntity_WorldAccelerator.onPostTick.crash\n" + e.getMessage()); + } + } + + private void doAccelerateTileEntities(IGregTechTileEntity pBaseMetaTileEntity, World pWorld) { + try { + if (!pBaseMetaTileEntity.isActive()) { + getBaseMetaTileEntity().setActive(true); + } + + for (ForgeDirection tDir : ForgeDirection.VALID_DIRECTIONS) { + TileEntity tTile = pBaseMetaTileEntity.getTileEntityAtSide(tDir); + if (isTEBlackListed(tTile)) { + continue; + } + + long tMaxTime = System.nanoTime() + 1000000; + for (int j = 0; j < mAccelerateStatic[getSpeedTierOverride()]; j++) { + tTile.updateEntity(); + if (System.nanoTime() > tMaxTime) { + break; + } + } + } + } catch (Exception e) { + GT_Log.err.println("GT_MetaTileEntity_WorldAccelerator.doAccelerateTileEntities.crash\n" + e.getMessage()); + } + } + + // Inspired by ChromatiCraft's TileAccelerator + private boolean isTEBlackListed(TileEntity pTile) { + if (pTile == null) { + return true; // Obvious + } + if (!pTile.canUpdate()) { + return true; // Skip if TE can't update at all + } + if (pTile.isInvalid()) { + return true; // Obvious + } + + String tSimpleClassName = simpleNameCache.get(pTile.getClass()); + String tCanonicalName = pTile.getClass() + .getCanonicalName() + .toLowerCase(); + if (tSimpleClassName.contains("conduit") || tSimpleClassName.contains("wire") + || tSimpleClassName.contains("cable")) { + return true; + } + if (tCanonicalName.contains("appeng") || tCanonicalName.contains(GregTech.ID)) // Don't accelerate ANY gregtech + // machines + { + return true; + } + if (tSimpleClassName.contains("solar") || tCanonicalName.contains("solar")) // Don't accelerate ANY solars + { + return true; + } + + for (String tS : GT_Values.blacklistedTileEntiyClassNamesForWA) { + if (tCanonicalName.equalsIgnoreCase(tS)) { + return true; + } + } + + return GT_MetaTileEntity_WorldAccelerator._mBlacklistedTiles.stream() + .map(Class::getCanonicalName) + .map(String::toLowerCase) + .anyMatch(tCanonicalName::equalsIgnoreCase); + } + + /** + * Accelerate normal blocks. Eats some power and adds randomTicks to every block within its working area + * (Tier-Number = radius) This does only affect blocks that implement the "RandomTick" method; Which is mostly used + * for grass growth and plants. + * + * @param pBaseMetaTileEntity + */ + private void doAccelerateNormalBlocks(IGregTechTileEntity pBaseMetaTileEntity, World pWorld) { + if (!pBaseMetaTileEntity.isActive()) { + getBaseMetaTileEntity().setActive(true); + } + + Random rnd = new Random(); + int tX = pBaseMetaTileEntity.getXCoord(); + int tY = pBaseMetaTileEntity.getYCoord(); + int tZ = pBaseMetaTileEntity.getZCoord(); + + int tX1 = tX - getRadiusTierOverride(); + int tX2 = tX + getRadiusTierOverride(); + int tY1 = Math.max(tY - getRadiusTierOverride(), 0); // Limit to bedrock + int tY2 = Math.min(tY + getRadiusTierOverride(), 255); // Limit to build height + int tZ1 = tZ - getRadiusTierOverride(); + int tZ2 = tZ + getRadiusTierOverride(); + + for (int xi = tX1; xi <= tX2; xi++) { + for (int yi = tY1; yi <= tY2; yi++) { + for (int zi = tZ1; zi <= tZ2; zi++) { + tryTickBlock(pWorld, xi, yi, zi, rnd); + } + } + } + } + + /** + * Send a tick to the target block + * + * @param pWorld + * @param pX + * @param pY + * @param pZ + * @param pRnd + */ + private void tryTickBlock(World pWorld, int pX, int pY, int pZ, Random pRnd) { + try { + for (int j = 0; j < getSpeedTierOverride(); j++) { + Block tBlock = pWorld.getBlock(pX, pY, pZ); + if (tBlock.getTickRandomly()) { + tBlock.updateTick(pWorld, pX, pY, pZ, pRnd); + } + } + } catch (Exception e) { + GT_Log.err.println("GT_MetaTileEntity_WorldAccelerator.tryTickBlock.crash\n" + e.getMessage()); + } + } +} |