From 1b820de08a05070909a267e17f033fcf58ac8710 Mon Sep 17 00:00:00 2001 From: NotAPenguin Date: Mon, 2 Sep 2024 23:17:17 +0200 Subject: The Great Renaming (#3014) * move kekztech to a single root dir * move detrav to a single root dir * move gtnh-lanthanides to a single root dir * move tectech and delete some gross reflection in gt++ * remove more reflection inside gt5u * delete more reflection in gt++ * fix imports * move bartworks and bwcrossmod * fix proxies * move galactigreg and ggfab * move gtneioreplugin * try to fix gt++ bee loader * apply the rename rules to BW * apply rename rules to bwcrossmod * apply rename rules to detrav scanner mod * apply rename rules to galacticgreg * apply rename rules to ggfab * apply rename rules to goodgenerator * apply rename rules to gtnh-lanthanides * apply rename rules to gt++ * apply rename rules to kekztech * apply rename rules to kubatech * apply rename rules to tectech * apply rename rules to gt apply the rename rules to gt * fix tt import * fix mui hopefully * fix coremod except intergalactic * rename assline recipe class * fix a class name i stumbled on * rename StructureUtility to GTStructureUtility to prevent conflict with structurelib * temporary rename of GTTooltipDataCache to old name * fix gt client/server proxy names --- .../system/material/BWGTMaterialReference.java | 523 +++++ .../system/material/BWItemMetaGeneratedBlock.java | 94 + .../system/material/BWMetaGeneratedBlocks.java | 130 ++ .../material/BWMetaGeneratedBlocksCasing.java | 121 ++ .../system/material/BWMetaGeneratedFrames.java | 144 ++ .../system/material/BWMetaGeneratedItems.java | 258 +++ .../system/material/BWMetaGeneratedOres.java | 133 ++ .../system/material/BWMetaGeneratedSmallOres.java | 76 + .../material/BWMetaGeneratedWerkstoffBlocks.java | 65 + .../system/material/BWNonMetaMaterialItems.java | 167 ++ .../BWTileEntityMetaGeneratedBlocksCasing.java | 50 + ...ileEntityMetaGeneratedBlocksCasingAdvanced.java | 50 + .../material/BWTileEntityMetaGeneratedOre.java | 116 ++ .../BWTileEntityMetaGeneratedSmallOre.java | 125 ++ .../BWTileEntityMetaGeneratedWerkstoffBlock.java | 49 + .../CircuitGeneration/BWCircuitsLoader.java | 25 + .../material/CircuitGeneration/BWMetaItems.java | 327 +++ .../material/CircuitGeneration/CircuitData.java | 76 + .../CircuitGeneration/CircuitImprintLoader.java | 367 ++++ .../CircuitGeneration/CircuitPartLoader.java | 265 +++ .../material/TileEntityMetaGeneratedBlock.java | 71 + .../java/bartworks/system/material/Werkstoff.java | 1263 ++++++++++++ .../bartworks/system/material/WerkstoffLoader.java | 2105 ++++++++++++++++++++ .../material/gtenhancement/BWGTMetaItems.java | 207 ++ .../material/gtenhancement/GTMetaItemEnhancer.java | 150 ++ .../gtenhancement/PlatinumSludgeOverHaul.java | 1102 ++++++++++ .../material/processingLoaders/AddSomeRecipes.java | 95 + .../processingLoaders/AdditionalRecipes.java | 537 +++++ .../material/processingLoaders/DownTierLoader.java | 47 + .../processingLoaders/LoadItemContainers.java | 76 + .../werkstoff_loaders/IWerkstoffRunnable.java | 21 + .../werkstoff_loaders/recipe/AspectLoader.java | 57 + .../werkstoff_loaders/recipe/BlockLoader.java | 73 + .../werkstoff_loaders/recipe/CasingLoader.java | 77 + .../werkstoff_loaders/recipe/CellLoader.java | 330 +++ .../recipe/CraftingMaterialLoader.java | 295 +++ .../werkstoff_loaders/recipe/CrushedLoader.java | 301 +++ .../werkstoff_loaders/recipe/DustLoader.java | 528 +++++ .../werkstoff_loaders/recipe/GemLoader.java | 294 +++ .../werkstoff_loaders/recipe/MetalLoader.java | 65 + .../werkstoff_loaders/recipe/MoltenCellLoader.java | 376 ++++ .../recipe/MultipleMetalLoader.java | 68 + .../werkstoff_loaders/recipe/OreLoader.java | 65 + .../werkstoff_loaders/recipe/RawOreLoader.java | 65 + .../recipe/SimpleMetalLoader.java | 249 +++ .../werkstoff_loaders/recipe/ToolLoader.java | 600 ++++++ .../registration/AssociationLoader.java | 41 + .../registration/BridgeMaterialsLoader.java | 171 ++ .../registration/CasingRegistrator.java | 39 + 49 files changed, 12529 insertions(+) create mode 100644 src/main/java/bartworks/system/material/BWGTMaterialReference.java create mode 100644 src/main/java/bartworks/system/material/BWItemMetaGeneratedBlock.java create mode 100644 src/main/java/bartworks/system/material/BWMetaGeneratedBlocks.java create mode 100644 src/main/java/bartworks/system/material/BWMetaGeneratedBlocksCasing.java create mode 100644 src/main/java/bartworks/system/material/BWMetaGeneratedFrames.java create mode 100644 src/main/java/bartworks/system/material/BWMetaGeneratedItems.java create mode 100644 src/main/java/bartworks/system/material/BWMetaGeneratedOres.java create mode 100644 src/main/java/bartworks/system/material/BWMetaGeneratedSmallOres.java create mode 100644 src/main/java/bartworks/system/material/BWMetaGeneratedWerkstoffBlocks.java create mode 100644 src/main/java/bartworks/system/material/BWNonMetaMaterialItems.java create mode 100644 src/main/java/bartworks/system/material/BWTileEntityMetaGeneratedBlocksCasing.java create mode 100644 src/main/java/bartworks/system/material/BWTileEntityMetaGeneratedBlocksCasingAdvanced.java create mode 100644 src/main/java/bartworks/system/material/BWTileEntityMetaGeneratedOre.java create mode 100644 src/main/java/bartworks/system/material/BWTileEntityMetaGeneratedSmallOre.java create mode 100644 src/main/java/bartworks/system/material/BWTileEntityMetaGeneratedWerkstoffBlock.java create mode 100644 src/main/java/bartworks/system/material/CircuitGeneration/BWCircuitsLoader.java create mode 100644 src/main/java/bartworks/system/material/CircuitGeneration/BWMetaItems.java create mode 100644 src/main/java/bartworks/system/material/CircuitGeneration/CircuitData.java create mode 100644 src/main/java/bartworks/system/material/CircuitGeneration/CircuitImprintLoader.java create mode 100644 src/main/java/bartworks/system/material/CircuitGeneration/CircuitPartLoader.java create mode 100644 src/main/java/bartworks/system/material/TileEntityMetaGeneratedBlock.java create mode 100644 src/main/java/bartworks/system/material/Werkstoff.java create mode 100644 src/main/java/bartworks/system/material/WerkstoffLoader.java create mode 100644 src/main/java/bartworks/system/material/gtenhancement/BWGTMetaItems.java create mode 100644 src/main/java/bartworks/system/material/gtenhancement/GTMetaItemEnhancer.java create mode 100644 src/main/java/bartworks/system/material/gtenhancement/PlatinumSludgeOverHaul.java create mode 100644 src/main/java/bartworks/system/material/processingLoaders/AddSomeRecipes.java create mode 100644 src/main/java/bartworks/system/material/processingLoaders/AdditionalRecipes.java create mode 100644 src/main/java/bartworks/system/material/processingLoaders/DownTierLoader.java create mode 100644 src/main/java/bartworks/system/material/processingLoaders/LoadItemContainers.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/IWerkstoffRunnable.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/AspectLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/BlockLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/CasingLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/CellLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/CraftingMaterialLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/CrushedLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/DustLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/GemLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/MetalLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/MoltenCellLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/MultipleMetalLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/OreLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/RawOreLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/SimpleMetalLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/recipe/ToolLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/registration/AssociationLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/registration/BridgeMaterialsLoader.java create mode 100644 src/main/java/bartworks/system/material/werkstoff_loaders/registration/CasingRegistrator.java (limited to 'src/main/java/bartworks/system/material') diff --git a/src/main/java/bartworks/system/material/BWGTMaterialReference.java b/src/main/java/bartworks/system/material/BWGTMaterialReference.java new file mode 100644 index 0000000000..50665464f4 --- /dev/null +++ b/src/main/java/bartworks/system/material/BWGTMaterialReference.java @@ -0,0 +1,523 @@ +/* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following + * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial + * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ +package bartworks.system.material; + +import bartworks.MainMod; +import gregtech.api.enums.Materials; + +public class BWGTMaterialReference { + + private static final Werkstoff.GenerationFeatures ADD_CASINGS_ONLY = new Werkstoff.GenerationFeatures().disable() + .addCasings(); + + public static Werkstoff Aluminium = new Werkstoff( + Materials.Aluminium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 19); + public static Werkstoff Americium = new Werkstoff( + Materials.Americium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 103); + public static Werkstoff Antimony = new Werkstoff( + Materials.Antimony, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 58); + public static Werkstoff Arsenic = new Werkstoff( + Materials.Arsenic, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 39); + public static Werkstoff Barium = new Werkstoff( + Materials.Barium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 63); + public static Werkstoff Beryllium = new Werkstoff( + Materials.Beryllium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 8); + public static Werkstoff Bismuth = new Werkstoff( + Materials.Bismuth, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 90); + public static Werkstoff Boron = new Werkstoff( + Materials.Boron, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 9); + public static Werkstoff Caesium = new Werkstoff( + Materials.Caesium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 62); + public static Werkstoff Carbon = new Werkstoff( + Materials.Carbon, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 10); + public static Werkstoff Cadmium = new Werkstoff( + Materials.Cadmium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 55); + public static Werkstoff Cerium = new Werkstoff( + Materials.Cerium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 65); + public static Werkstoff Chrome = new Werkstoff( + Materials.Chrome, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 30); + public static Werkstoff Cobalt = new Werkstoff( + Materials.Cobalt, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 33); + public static Werkstoff Copper = new Werkstoff( + Materials.Copper, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 35); + public static Werkstoff Dysprosium = new Werkstoff( + Materials.Dysprosium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 73); + public static Werkstoff Erbium = new Werkstoff( + Materials.Erbium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 75); + public static Werkstoff Europium = new Werkstoff( + Materials.Europium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 70); + public static Werkstoff Gadolinium = new Werkstoff( + Materials.Gadolinium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 71); + public static Werkstoff Gallium = new Werkstoff( + Materials.Gallium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 37); + public static Werkstoff Gold = new Werkstoff( + Materials.Gold, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 86); + public static Werkstoff Holmium = new Werkstoff( + Materials.Holmium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 74); + public static Werkstoff Indium = new Werkstoff( + Materials.Indium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 56); + public static Werkstoff Iridium = new Werkstoff( + Materials.Iridium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 84); + public static Werkstoff Iron = new Werkstoff( + Materials.Iron, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 32); + public static Werkstoff Lanthanum = new Werkstoff( + Materials.Lanthanum, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 64); + public static Werkstoff Lead = new Werkstoff( + Materials.Lead, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 89); + public static Werkstoff Lithium = new Werkstoff( + Materials.Lithium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 6); + public static Werkstoff Lutetium = new Werkstoff( + Materials.Lutetium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 78); + public static Werkstoff Magnesium = new Werkstoff( + Materials.Magnesium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 18); + public static Werkstoff Manganese = new Werkstoff( + Materials.Manganese, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 31); + public static Werkstoff Molybdenum = new Werkstoff( + Materials.Molybdenum, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 48); + public static Werkstoff Neodymium = new Werkstoff( + Materials.Neodymium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 67); + public static Werkstoff Neutronium = new Werkstoff( + Materials.Neutronium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 129); + public static Werkstoff Nickel = new Werkstoff( + Materials.Nickel, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 34); + public static Werkstoff Niobium = new Werkstoff( + Materials.Niobium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 47); + public static Werkstoff Osmium = new Werkstoff( + Materials.Osmium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 83); + public static Werkstoff Palladium = new Werkstoff( + Materials.Palladium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 52); + public static Werkstoff Phosphorus = new Werkstoff( + Materials.Phosphorus, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 21); + public static Werkstoff Platinum = new Werkstoff( + Materials.Platinum, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 85); + public static Werkstoff Plutonium241 = new Werkstoff( + Materials.Plutonium241, + ADD_CASINGS_ONLY, + Werkstoff.Types.ISOTOPE, + 31_766 + 101); + public static Werkstoff Potassium = new Werkstoff( + Materials.Potassium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 25); + public static Werkstoff Praseodymium = new Werkstoff( + Materials.Praseodymium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 66); + public static Werkstoff Promethium = new Werkstoff( + Materials.Promethium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 68); + public static Werkstoff Rubidium = new Werkstoff( + Materials.Rubidium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 43); + public static Werkstoff Samarium = new Werkstoff( + Materials.Samarium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 69); + public static Werkstoff Scandium = new Werkstoff( + Materials.Scandium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 27); + public static Werkstoff Silicon = new Werkstoff( + Materials.Silicon, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 20); + public static Werkstoff Silver = new Werkstoff( + Materials.Silver, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 54); + public static Werkstoff Sodium = new Werkstoff( + Materials.Sodium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 17); + public static Werkstoff Strontium = new Werkstoff( + Materials.Strontium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 44); + public static Werkstoff Sulfur = new Werkstoff( + Materials.Sulfur, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 22); + public static Werkstoff Tantalum = new Werkstoff( + Materials.Tantalum, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 80); + public static Werkstoff Terbium = new Werkstoff( + Materials.Terbium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 72); + public static Werkstoff Thorium = new Werkstoff( + Materials.Thorium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 96); + public static Werkstoff Thulium = new Werkstoff( + Materials.Thulium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 76); + public static Werkstoff Tin = new Werkstoff(Materials.Tin, ADD_CASINGS_ONLY, Werkstoff.Types.ELEMENT, 31_766 + 57); + public static Werkstoff Titanium = new Werkstoff( + Materials.Titanium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 28); + public static Werkstoff Tritanium = new Werkstoff( + Materials.Tritanium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 329); + public static Werkstoff Tritium = new Werkstoff( + Materials.Tritium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 3); + public static Werkstoff Tungsten = new Werkstoff( + Materials.Tungsten, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 81); + public static Werkstoff Uranium = new Werkstoff( + Materials.Uranium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 98); + public static Werkstoff Uranium235 = new Werkstoff( + Materials.Uranium235, + ADD_CASINGS_ONLY, + Werkstoff.Types.ISOTOPE, + 31_766 + 97); + public static Werkstoff Vanadium = new Werkstoff( + Materials.Vanadium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 29); + public static Werkstoff Ytterbium = new Werkstoff( + Materials.Ytterbium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 77); + public static Werkstoff Yttrium = new Werkstoff( + Materials.Yttrium, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 45); + public static Werkstoff Zinc = new Werkstoff( + Materials.Zinc, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 36); + public static Werkstoff Ardite = new Werkstoff( + Materials.Ardite, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 382); + public static Werkstoff Naquadah = new Werkstoff( + Materials.Naquadah, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 324); + public static Werkstoff NaquadahAlloy = new Werkstoff( + Materials.NaquadahAlloy, + ADD_CASINGS_ONLY, + Werkstoff.Types.COMPOUND, + 31_766 + 325); + public static Werkstoff NaquadahEnriched = new Werkstoff( + Materials.NaquadahEnriched, + ADD_CASINGS_ONLY, + Werkstoff.Types.ISOTOPE, + 31_766 + 326); + public static Werkstoff Naquadria = new Werkstoff( + Materials.Naquadria, + ADD_CASINGS_ONLY, + Werkstoff.Types.ELEMENT, + 31_766 + 327); + public static Werkstoff WroughtIron = new Werkstoff( + Materials.WroughtIron, + ADD_CASINGS_ONLY, + Werkstoff.Types.ISOTOPE, + 31_766 + 304); + public static Werkstoff AnnealedCopper = new Werkstoff( + Materials.AnnealedCopper, + ADD_CASINGS_ONLY, + Werkstoff.Types.ISOTOPE, + 31_766 + 345); + + public static Werkstoff Osmiridium = new Werkstoff( + Materials.Osmiridium, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 317); + public static Werkstoff SterlingSilver = new Werkstoff( + Materials.SterlingSilver, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 350); + public static Werkstoff RoseGold = new Werkstoff( + Materials.RoseGold, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 351); + public static Werkstoff BlackBronze = new Werkstoff( + Materials.BlackBronze, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 352); + public static Werkstoff BismuthBronze = new Werkstoff( + Materials.BismuthBronze, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 353); + public static Werkstoff BlackSteel = new Werkstoff( + Materials.BlackSteel, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 334); + public static Werkstoff RedSteel = new Werkstoff( + Materials.RedSteel, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 348); + public static Werkstoff BlueSteel = new Werkstoff( + Materials.BlueSteel, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 349); + public static Werkstoff DamascusSteel = new Werkstoff( + Materials.DamascusSteel, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 335); + public static Werkstoff TungstenSteel = new Werkstoff( + Materials.TungstenSteel, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 316); + public static Werkstoff Ultimet = new Werkstoff( + Materials.Ultimet, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 344); + public static Werkstoff TungstenCarbide = new Werkstoff( + Materials.TungstenCarbide, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 370); + public static Werkstoff VanadiumSteel = new Werkstoff( + Materials.VanadiumSteel, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 371); + public static Werkstoff HSSG = new Werkstoff( + Materials.HSSG, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 372); + public static Werkstoff HSSE = new Werkstoff( + Materials.HSSE, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 373); + public static Werkstoff HSSS = new Werkstoff( + Materials.HSSS, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 374); + public static Werkstoff StainlessSteel = new Werkstoff( + Materials.StainlessSteel, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 306); + public static Werkstoff Brass = new Werkstoff( + Materials.Brass, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 301); + public static Werkstoff Bronze = new Werkstoff( + Materials.Bronze, + ADD_CASINGS_ONLY, + Werkstoff.Types.MIXTURE, + 31_766 + 300); + + public static Werkstoff Wood = new Werkstoff( + Materials.Wood, + ADD_CASINGS_ONLY, + Werkstoff.Types.BIOLOGICAL, + 31_766 + 809); + + public static Werkstoff Steel = new Werkstoff( + Materials.Steel, + ADD_CASINGS_ONLY, + Werkstoff.Types.COMPOUND, + 31_766 + 305); + public static Werkstoff Polytetrafluoroethylene = new Werkstoff( + Materials.Polytetrafluoroethylene, + ADD_CASINGS_ONLY, + Werkstoff.Types.COMPOUND, + 31_766 + 473); + public static Werkstoff Plastic = new Werkstoff( + Materials.Plastic, + ADD_CASINGS_ONLY, + Werkstoff.Types.COMPOUND, + 31_766 + 874); + public static Werkstoff Epoxid = new Werkstoff( + Materials.Epoxid, + ADD_CASINGS_ONLY, + Werkstoff.Types.COMPOUND, + 31_766 + 470); + public static Werkstoff Magnesia = new Werkstoff( + Materials.Magnesia, + new Werkstoff.GenerationFeatures().disable() + .addMetalItems() + .addMolten(), + Werkstoff.Types.COMPOUND, + 31_766 + 471); + + public static void init() { + MainMod.LOGGER.info("Load Elements from GT"); + } +} diff --git a/src/main/java/bartworks/system/material/BWItemMetaGeneratedBlock.java b/src/main/java/bartworks/system/material/BWItemMetaGeneratedBlock.java new file mode 100644 index 0000000000..671b21e92b --- /dev/null +++ b/src/main/java/bartworks/system/material/BWItemMetaGeneratedBlock.java @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following + * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial + * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +package bartworks.system.material; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +import bartworks.common.items.BWItemBlocks; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.util.GTLanguageManager; +import gregtech.api.util.GTUtility; + +public class BWItemMetaGeneratedBlock extends BWItemBlocks { + + public BWItemMetaGeneratedBlock(Block par1) { + super(par1); + } + + @Override + public boolean onItemUseFirst(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, + float hitX, float hitY, float hitZ) { + return false; + } + + @Override + public String getUnlocalizedName(ItemStack aStack) { + return this.field_150939_a.getUnlocalizedName() + "." + this.getDamage(aStack); + } + + @Override + public String getItemStackDisplayName(ItemStack aStack) { + Block block = Block.getBlockFromItem(aStack.getItem()); + if (block instanceof BWMetaGeneratedBlocks metaBlock) { + int aMetaData = aStack.getItemDamage(); + Werkstoff werkstoff = Werkstoff.werkstoffHashMap.get((short) aMetaData); + if (werkstoff == null) werkstoff = Werkstoff.default_null_Werkstoff; + return metaBlock.blockTypeLocalizedName.replace("%material", werkstoff.getLocalizedName()); + } + return GTLanguageManager.getTranslation(this.getUnlocalizedName(aStack) + ".name"); + } + + @Override + @SideOnly(Side.CLIENT) + public void addInformation(ItemStack aStack, EntityPlayer aPlayer, List aList, boolean aF3_H) { + if (!GTUtility.isStackValid(aStack) || aPlayer == null || aStack.getItemDamage() <= 0) { + return; + } + if (aList == null) { + aList = new ArrayList<>(); + } + Werkstoff werkstoff = Werkstoff.werkstoffHashMap.get((short) aStack.getItemDamage()); + if (werkstoff != null) { + String tooltip = werkstoff.getLocalizedToolTip(); + if (!tooltip.isEmpty()) { + aList.add(tooltip); + } + } + } + + @Override + public boolean placeBlockAt(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, int side, + float hitX, float hitY, float hitZ, int aMeta) { + short tDamage = (short) this.getDamage(aStack); + if (tDamage > 0) { + if (!aWorld.setBlock(aX, aY, aZ, this.field_150939_a, tDamage, 3)) { + return false; + } + TileEntityMetaGeneratedBlock tTileEntity = (TileEntityMetaGeneratedBlock) aWorld.getTileEntity(aX, aY, aZ); + tTileEntity.mMetaData = tDamage; + } else if (!aWorld.setBlock(aX, aY, aZ, this.field_150939_a, 0, 3)) return false; + if (aWorld.getBlock(aX, aY, aZ) == this.field_150939_a) { + this.field_150939_a.onBlockPlacedBy(aWorld, aX, aY, aZ, aPlayer, aStack); + this.field_150939_a.onPostBlockPlaced(aWorld, aX, aY, aZ, tDamage); + } + return true; + } +} diff --git a/src/main/java/bartworks/system/material/BWMetaGeneratedBlocks.java b/src/main/java/bartworks/system/material/BWMetaGeneratedBlocks.java new file mode 100644 index 0000000000..db838d059a --- /dev/null +++ b/src/main/java/bartworks/system/material/BWMetaGeneratedBlocks.java @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following + * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial + * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +package bartworks.system.material; + +import static bartworks.system.material.BWMetaGeneratedItems.metaTab; + +import java.util.ArrayList; + +import net.minecraft.block.Block; +import net.minecraft.block.ITileEntityProvider; +import net.minecraft.block.material.Material; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +import bartworks.client.renderer.BWBlockOreRenderer; +import bartworks.common.blocks.BWTileEntityContainer; +import bartworks.util.BWUtil; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GTLanguageManager; + +public abstract class BWMetaGeneratedBlocks extends BWTileEntityContainer { + + public static ThreadLocal mTemporaryTileEntity = new ThreadLocal<>(); + protected OrePrefixes _prefixes; + protected String blockTypeLocalizedName; + + public BWMetaGeneratedBlocks(Material p_i45386_1_, Class tileEntity, String blockName) { + this(p_i45386_1_, tileEntity, blockName, null); + } + + public BWMetaGeneratedBlocks(Material p_i45386_1_, Class tileEntity, String blockName, + OrePrefixes types) { + super(p_i45386_1_, tileEntity, blockName); + this.setHardness(5.0F); + this.setResistance(5.0F); + this.setBlockTextureName("stone"); + this.setCreativeTab(metaTab); + this._prefixes = types; + if (this._prefixes != null) { + this.blockTypeLocalizedName = GTLanguageManager.addStringLocalization( + "bw.blocktype." + this._prefixes, + this._prefixes.mLocalizedMaterialPre + "%material" + this._prefixes.mLocalizedMaterialPost); + } + Werkstoff.werkstoffHashSet.forEach(this::doRegistrationStuff); + } + + @Override + public void onBlockAdded(World aWorld, int aX, int aY, int aZ) { + super.onBlockAdded(aWorld, aX, aY, aZ); + // Waste some time to allow the TE to be set, do not use thread sleep here, it doesnt allow for nanoseconds. + // This will just waste a few cpu cycles to allow the TE to be set + BWUtil.shortSleep(0); + } + + @SideOnly(Side.CLIENT) + public final TileEntityMetaGeneratedBlock getProperTileEntityForRendering() { + return (TileEntityMetaGeneratedBlock) this.createNewTileEntity(null, 0); + } + + protected abstract void doRegistrationStuff(Werkstoff w); + + @Override + public String getHarvestTool(int metadata) { + return "pickaxe"; + } + + @Override + protected boolean canSilkHarvest() { + return false; + } + + @Override + public int getRenderType() { + if (BWBlockOreRenderer.INSTANCE == null) return super.getRenderType(); + return BWBlockOreRenderer.INSTANCE.renderID; + } + + @Override + public int getDamageValue(World aWorld, int aX, int aY, int aZ) { + TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (tTileEntity instanceof TileEntityMetaGeneratedBlock metaTE) { + return metaTE.mMetaData; + } + return 0; + } + + @Override + public TileEntity createTileEntity(World world, int metadata) { + return ((ITileEntityProvider) this).createNewTileEntity(world, metadata); + } + + @Override + public boolean hasTileEntity(int metadata) { + return true; + } + + @Override + public void breakBlock(World world, int x, int y, int z, Block block, int meta) { + TileEntity tTileEntity = world.getTileEntity(x, y, z); + if (tTileEntity instanceof TileEntityMetaGeneratedBlock metaTE) { + mTemporaryTileEntity.set(metaTE); + } + super.breakBlock(world, x, y, z, block, meta); + } + + @Override + public ArrayList getDrops(World aWorld, int aX, int aY, int aZ, int aMeta, int aFortune) { + TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (tTileEntity instanceof TileEntityMetaGeneratedBlock metaTE) { + return metaTE.getDrops(aFortune); + } + return mTemporaryTileEntity.get() == null ? new ArrayList<>() + : mTemporaryTileEntity.get() + .getDrops(aFortune); + } +} diff --git a/src/main/java/bartworks/system/material/BWMetaGeneratedBlocksCasing.java b/src/main/java/bartworks/system/material/BWMetaGeneratedBlocksCasing.java new file mode 100644 index 0000000000..f8ed670092 --- /dev/null +++ b/src/main/java/bartworks/system/material/BWMetaGeneratedBlocksCasing.java @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following + * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial + * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +package bartworks.system.material; + +import java.util.List; +import java.util.Optional; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.Entity; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTechAPI; +import gregtech.api.enums.OrePrefixes; + +public class BWMetaGeneratedBlocksCasing extends BWMetaGeneratedBlocks + implements com.gtnewhorizon.structurelib.structure.ICustomBlockSetting { + + public BWMetaGeneratedBlocksCasing(Material p_i45386_1_, Class tileEntity, String blockName, + OrePrefixes prefixes) { + super(p_i45386_1_, tileEntity, blockName, prefixes); + } + + @Override + public String getHarvestTool(int aMeta) { + return "wrench"; + } + + @Override + public int getHarvestLevel(int aMeta) { + return 2; + } + + @Override + public float getBlockHardness(World aWorld, int aX, int aY, int aZ) { + return Blocks.iron_block.getBlockHardness(aWorld, aX, aY, aZ); + } + + @Override + public float getExplosionResistance(Entity aTNT) { + return Blocks.iron_block.getExplosionResistance(aTNT); + } + + @Override + protected boolean canSilkHarvest() { + return false; + } + + @Override + public void breakBlock(World aWorld, int aX, int aY, int aZ, Block aBlock, int aMetaData) { + GregTechAPI.causeMachineUpdate(aWorld, aX, aY, aZ); + super.breakBlock(aWorld, aX, aY, aZ, aBlock, aMetaData); + } + + @Override + public void onBlockAdded(World aWorld, int aX, int aY, int aZ) { + super.onBlockAdded(aWorld, aX, aY, aZ); + GregTechAPI.causeMachineUpdate(aWorld, aX, aY, aZ); + } + + @Override + protected void doRegistrationStuff(Werkstoff tMaterial) { + GregTechAPI.registerMachineBlock(this, -1); + } + + @Override + public String getUnlocalizedName() { + if (this._prefixes == OrePrefixes.blockCasing) return "bw.werkstoffblockscasing.01"; + if (this._prefixes == OrePrefixes.blockCasingAdvanced) return "bw.werkstoffblockscasingadvanced.01"; + return ""; + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubBlocks(Item aItem, CreativeTabs aTab, List aList) { + Werkstoff.werkstoffHashSet.stream() + .filter( + pMaterial -> Werkstoff.Types.BIOLOGICAL.equals(pMaterial.getType()) + && pMaterial.hasGenerationFeature(OrePrefixes.blockCasing) + || pMaterial.doesOreDictedItemExists(OrePrefixes.plate) + && pMaterial.doesOreDictedItemExists(OrePrefixes.screw) + && pMaterial.doesOreDictedItemExists(OrePrefixes.plateDouble) + && pMaterial.doesOreDictedItemExists(OrePrefixes.gearGt) + && pMaterial.doesOreDictedItemExists(OrePrefixes.gearGtSmall)) + .map(pMaterial -> new ItemStack(aItem, 1, pMaterial.getmID())) + .forEach(aList::add); + } + + /** + * ICustomBlockSetting setBlock override + */ + public void setBlock(World world, int x, int y, int z, int meta) { + world.setBlock(x, y, z, this, meta, 2); + try { + Thread.sleep(1); + // Fucking Minecraft TE settings. + } catch (InterruptedException ignored) {} + Optional.ofNullable(world.getTileEntity(x, y, z)) + .filter(te -> te instanceof TileEntityMetaGeneratedBlock) + .map(te -> (TileEntityMetaGeneratedBlock) te) + .ifPresent(te -> te.mMetaData = (short) meta); + } +} diff --git a/src/main/java/bartworks/system/material/BWMetaGeneratedFrames.java b/src/main/java/bartworks/system/material/BWMetaGeneratedFrames.java new file mode 100644 index 0000000000..092ccf038b --- /dev/null +++ b/src/main/java/bartworks/system/material/BWMetaGeneratedFrames.java @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following + * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial + * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +package bartworks.system.material; + +import static gregtech.api.enums.GTValues.RA; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.util.GTRecipeBuilder.SECONDS; +import static gregtech.api.util.GTRecipeBuilder.TICKS; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.enums.Dyes; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaPipeEntity; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GTModHandler; +import gregtech.api.util.GTModHandler.RecipeBits; +import gregtech.api.util.GTOreDictUnificator; + +public class BWMetaGeneratedFrames extends MetaPipeEntity { + + public final Werkstoff mMaterial; + + public BWMetaGeneratedFrames(int aID, String aName, String aNameRegional, Werkstoff aMaterial) { + super(aID, aName, aNameRegional, 0); + this.mMaterial = aMaterial; + + GTOreDictUnificator.registerOre(OrePrefixes.frameGt, aMaterial, this.getStackForm(1)); + GTModHandler.addCraftingRecipe( + this.getStackForm(2), + RecipeBits.NOT_REMOVABLE | GTModHandler.RecipeBits.BUFFERED, + new Object[] { "SSS", "SwS", "SSS", 'S', this.mMaterial.get(OrePrefixes.stick) }); + + RA.stdBuilder() + .itemInputs( + GTOreDictUnificator.get(OrePrefixes.stick, aMaterial.getVarName(), 4), + ItemList.Circuit_Integrated.getWithDamage(0, 4)) + .itemOutputs(getStackForm(1)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(8) + .addTo(assemblerRecipes); + } + + private BWMetaGeneratedFrames(String aName, Werkstoff aMaterial) { + super(aName, 0); + this.mMaterial = aMaterial; + } + + @Override + public byte getTileEntityBaseType() { + return 4; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new BWMetaGeneratedFrames(this.mName, this.mMaterial); + } + + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, byte aConnections, + int aColorIndex, boolean aConnected, boolean aRedstone) { + return new ITexture[] { TextureFactory.of( + this.mMaterial.getTexSet().mTextures[OrePrefixes.frameGt.mTextureIndex], + Dyes.getModulation(aColorIndex, this.mMaterial.getRGBA())) }; + } + + @Override + public String[] getDescription() { + return new String[] { "Just something you can put a Cover or CFoam on." }; + } + + @Override + public final boolean isSimpleMachine() { + return true; + } + + @Override + public final boolean isFacingValid(ForgeDirection facing) { + return false; + } + + @Override + public final boolean isValidSlot(int aIndex) { + return false; + } + + @Override + public final boolean renderInside(ForgeDirection side) { + return true; + } + + @Override + public final float getThickNess() { + return 1.0F; + } + + @Override + public final void saveNBTData(NBTTagCompound aNBT) { + /* Do nothing */ + } + + @Override + public final void loadNBTData(NBTTagCompound aNBT) { + /* Do nothing */ + } + + @Override + public final boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return false; + } + + @Override + public final boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return false; + } + + @Override + public int connect(ForgeDirection side) { + return 0; + } + + @Override + public void disconnect(ForgeDirection side) { + /* Do nothing */ + } +} diff --git a/src/main/java/bartworks/system/material/BWMetaGeneratedItems.java b/src/main/java/bartworks/system/material/BWMetaGeneratedItems.java new file mode 100644 index 0000000000..bdeab62cfd --- /dev/null +++ b/src/main/java/bartworks/system/material/BWMetaGeneratedItems.java @@ -0,0 +1,258 @@ +/* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following + * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial + * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +package bartworks.system.material; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.potion.Potion; +import net.minecraft.potion.PotionEffect; +import net.minecraft.util.IIcon; +import net.minecraft.util.MathHelper; +import net.minecraft.world.World; + +import bartworks.API.IRadMaterial; +import bartworks.API.SideReference; +import bartworks.client.textures.PrefixTextureLinker; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.items.MetaGeneratedItem; +import gregtech.api.util.GTLanguageManager; +import gregtech.api.util.GTOreDictUnificator; +import gregtech.api.util.GTUtility; +import ic2.core.IC2Potion; + +public class BWMetaGeneratedItems extends MetaGeneratedItem implements IRadMaterial { + + public static final CreativeTabs metaTab = new CreativeTabs("bartworksMetaMaterials") { + + @Override + public Item getTabIconItem() { + return new ItemStack(Blocks.iron_ore).getItem(); + } + }; + + protected final OrePrefixes orePrefixes; + protected final String itemTypeLocalizedName; + + public BWMetaGeneratedItems(OrePrefixes orePrefixes, Object unused) { + super("bwMetaGeneratedGTEnhancement" + orePrefixes.name(), (short) 32766, (short) 0); + this.orePrefixes = orePrefixes; + this.itemTypeLocalizedName = GTLanguageManager.addStringLocalization( + "bw.itemtype." + orePrefixes, + orePrefixes.mLocalizedMaterialPre + "%material" + orePrefixes.mLocalizedMaterialPost); + } + + public BWMetaGeneratedItems(OrePrefixes orePrefixes) { + super("bwMetaGenerated" + orePrefixes.name(), (short) 32766, (short) 0); + this.orePrefixes = orePrefixes; + this.itemTypeLocalizedName = GTLanguageManager.addStringLocalization( + "bw.itemtype." + orePrefixes, + orePrefixes.mLocalizedMaterialPre + "%material" + orePrefixes.mLocalizedMaterialPost); + this.setCreativeTab(BWMetaGeneratedItems.metaTab); + for (Werkstoff w : Werkstoff.werkstoffHashSet) { + ItemStack tStack = new ItemStack(this, 1, w.getmID()); + if (!w.hasItemType(this.orePrefixes)) continue; + GTOreDictUnificator.registerOre(this.orePrefixes.name() + w.getVarName(), tStack); + } + } + + @Override + public boolean onEntityItemUpdate(EntityItem aItemEntity) { + if (this.orePrefixes == OrePrefixes.dustImpure || this.orePrefixes == OrePrefixes.dustPure + || this.orePrefixes == OrePrefixes.crushed) { + int aDamage = aItemEntity.getEntityItem() + .getItemDamage(); + if (aDamage >= 0 && !aItemEntity.worldObj.isRemote) { + Werkstoff aMaterial = Werkstoff.werkstoffHashMap.get((short) aDamage); + if (aMaterial != null && aMaterial != Werkstoff.default_null_Werkstoff) { + int tX = MathHelper.floor_double(aItemEntity.posX); + int tY = MathHelper.floor_double(aItemEntity.posY); + int tZ = MathHelper.floor_double(aItemEntity.posZ); + Block tBlock = aItemEntity.worldObj.getBlock(tX, tY, tZ); + byte tMetaData = (byte) aItemEntity.worldObj.getBlockMetadata(tX, tY, tZ); + if (tBlock == Blocks.cauldron && tMetaData > 0) { + if (this.orePrefixes == OrePrefixes.dustImpure || this.orePrefixes == OrePrefixes.dustPure) { + aItemEntity.setEntityItemStack( + WerkstoffLoader.getCorrespondingItemStack( + OrePrefixes.dust, + aMaterial, + aItemEntity.getEntityItem().stackSize)); + aItemEntity.worldObj.setBlockMetadataWithNotify(tX, tY, tZ, tMetaData - 1, 3); + return true; + } else { + aItemEntity.setEntityItemStack( + WerkstoffLoader.getCorrespondingItemStack( + OrePrefixes.crushedPurified, + aMaterial, + aItemEntity.getEntityItem().stackSize)); + aItemEntity.worldObj.setBlockMetadataWithNotify(tX, tY, tZ, tMetaData - 1, 3); + return true; + } + } + } + } + } + return false; + } + + @Override + protected void addAdditionalToolTips(List aList, ItemStack aStack, EntityPlayer aPlayer) { + if (this.orePrefixes == OrePrefixes.dustImpure || this.orePrefixes == OrePrefixes.dustPure) { + aList.add(GTLanguageManager.getTranslation("metaitem.01.tooltip.purify")); + } + if (this.orePrefixes == OrePrefixes.crushed) + aList.add(GTLanguageManager.getTranslation("metaitem.01.tooltip.purify.2")); + + if (aStack != null && aStack.getItem() instanceof BWMetaGeneratedItems + && aStack.getItemDamage() == WerkstoffLoader.Tiberium.getmID()) + aList.add(GTLanguageManager.getTranslation("metaitem.01.tooltip.nqgen")); + + Werkstoff werkstoff = Werkstoff.werkstoffHashMap.get((short) this.getDamage(aStack)); + if (werkstoff != null) { + String tooltip = werkstoff.getLocalizedToolTip(); + if (!tooltip.isEmpty()) { + aList.add(tooltip); + } + } + } + + @Override + public String getItemStackDisplayName(ItemStack aStack) { + int aMetaData = aStack.getItemDamage(); + Werkstoff werkstoff = Werkstoff.werkstoffHashMap.get((short) aMetaData); + if (werkstoff == null) werkstoff = Werkstoff.default_null_Werkstoff; + return this.itemTypeLocalizedName.replace("%material", werkstoff.getLocalizedName()); + } + + @Override + public IIconContainer getIconContainer(int aMetaData) { + if (Werkstoff.werkstoffHashMap.get((short) aMetaData) == null) return null; + if (this.orePrefixes.mTextureIndex == -1) return this.getIconContainerBartWorks(aMetaData); + return Werkstoff.werkstoffHashMap.get((short) aMetaData) + .getTexSet().mTextures[this.orePrefixes.mTextureIndex]; + } + + protected IIconContainer getIconContainerBartWorks(int aMetaData) { + if (SideReference.Side.Client) return PrefixTextureLinker.texMap.get(this.orePrefixes) + .get( + Werkstoff.werkstoffHashMap.get((short) aMetaData) + .getTexSet()); + return null; + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item var1, CreativeTabs aCreativeTab, List aList) { + for (Werkstoff werkstoff : Werkstoff.werkstoffHashSet) { + if (werkstoff != null && werkstoff.hasItemType(this.orePrefixes)) { + ItemStack tStack = new ItemStack(this, 1, werkstoff.getmID()); + aList.add(tStack); + } + } + // super.getSubItems(var1, aCreativeTab, aList); + } + + @Override + public short[] getRGBa(ItemStack aStack) { + Werkstoff werkstoff = Werkstoff.werkstoffHashMap.get((short) this.getDamage(aStack)); + return werkstoff == null ? Materials._NULL.mRGBa : werkstoff.getRGBA(); + } + + @Override + public void onUpdate(ItemStack aStack, World aWorld, Entity aPlayer, int aTimer, boolean aIsInHand) { + super.onUpdate(aStack, aWorld, aPlayer, aTimer, aIsInHand); + if (aStack == null || aStack.getItem() == null || !(aPlayer instanceof EntityLivingBase)) return; + + EntityLivingBase bPlayer = (EntityPlayer) aPlayer; + Werkstoff w = Werkstoff.werkstoffHashMap.get((short) aStack.getItemDamage()); + if (w == null || w.getStats() == null) return; + + if (w.getStats() + .isToxic() && !GTUtility.isWearingFullBioHazmat(bPlayer)) { + bPlayer.addPotionEffect(new PotionEffect(Potion.poison.getId(), 80, 4)); + } + + if (w.getStats() + .isRadioactive() && !GTUtility.isWearingFullRadioHazmat(bPlayer)) { + bPlayer.addPotionEffect(new PotionEffect(IC2Potion.radiation.id, 80, 4)); + } + } + + @Override + public IIcon getIconFromDamage(int aMetaData) { + if (aMetaData < 0) return null; + Werkstoff tMaterial = Werkstoff.werkstoffHashMap.get((short) aMetaData); + if (tMaterial == null) return null; + IIconContainer tIcon = this.getIconContainer(aMetaData); + if (tIcon != null) return tIcon.getIcon(); + return null; + } + + @Override + public int getItemStackLimit(ItemStack aStack) { + return this.orePrefixes.mDefaultStackSize; + } + + @Override + public int getRadiationLevel(ItemStack aStack) { + Werkstoff w = Werkstoff.werkstoffHashMap.get((short) aStack.getItemDamage()); + return w.getStats() + .isRadioactive() + ? (int) w.getStats() + .getProtons() + : 0; + } + + @Override + public byte getAmountOfMaterial(ItemStack aStack) { + return (byte) (this.orePrefixes == OrePrefixes.stick ? 1 : this.orePrefixes == OrePrefixes.stickLong ? 2 : 0); + } + + @Override + public short[] getColorForGUI(ItemStack aStack) { + Werkstoff w = Werkstoff.werkstoffHashMap.get((short) aStack.getItemDamage()); + return w.getRGBA(); + } + + @Override + public String getNameForGUI(ItemStack aStack) { + Werkstoff w = Werkstoff.werkstoffHashMap.get((short) aStack.getItemDamage()); + return w.getDefaultName(); + } + + @Override + public int getCapacity(ItemStack aStack) { + return this.orePrefixes == OrePrefixes.capsule || this.orePrefixes == OrePrefixes.cell + || this.orePrefixes == OrePrefixes.cellPlasma ? 1000 + : this.orePrefixes == OrePrefixes.cellMolten || this.orePrefixes == OrePrefixes.capsuleMolten ? 144 : 0; + } + + @Override + public ItemStack getContainerItem(ItemStack aStack) { + return this.orePrefixes == OrePrefixes.cell || this.orePrefixes == OrePrefixes.cellPlasma + || this.orePrefixes == OrePrefixes.cellMolten ? Materials.Empty.getCells(1) : null; + } +} diff --git a/src/main/java/bartworks/system/material/BWMetaGeneratedOres.java b/src/main/java/bartworks/system/material/BWMetaGeneratedOres.java new file mode 100644 index 0000000000..c74c3f01cb --- /dev/null +++ b/src/main/java/bartworks/system/material/BWMetaGeneratedOres.java @@ -0,0 +1,133 @@ +/* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following + * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial + * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +package bartworks.system.material; + +import java.util.Arrays; +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.enchantment.EnchantmentHelper; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraftforge.common.util.FakePlayer; + +import bartworks.util.MathUtils; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GTLanguageManager; +import gregtech.api.util.GTModHandler; + +public class BWMetaGeneratedOres extends BWMetaGeneratedBlocks { + + public BWMetaGeneratedOres(Material p_i45386_1_, Class tileEntity, String blockName) { + super(p_i45386_1_, tileEntity, blockName); + this.blockTypeLocalizedName = GTLanguageManager.addStringLocalization( + "bw.blocktype." + OrePrefixes.ore, + OrePrefixes.ore.mLocalizedMaterialPre + "%material" + OrePrefixes.ore.mLocalizedMaterialPost); + } + + @Override + protected void doRegistrationStuff(Werkstoff w) { + if (w != null) { + if (!w.hasItemType(OrePrefixes.ore) || (w.getGenerationFeatures().blacklist & 0b1000) != 0) return; + GTModHandler.addValuableOre(this, w.getmID(), 1); + } + } + + public static boolean setOreBlock(World aWorld, int aX, int aY, int aZ, int aMetaData, boolean air, Block block, + int[] aBlockMeta) { + if (!air) { + aY = MathUtils.clamp(aY, 1, aWorld.getActualHeight()); + } + + Block tBlock = aWorld.getBlock(aX, aY, aZ); + Block tOreBlock = WerkstoffLoader.BWOres; + if (aMetaData < 0 || tBlock == Blocks.air && !air + || Block.getIdFromBlock(tBlock) != Block.getIdFromBlock(block)) { + return false; + } +