From 4b60d5c851f942d176038c386946469d839eabc7 Mon Sep 17 00:00:00 2001 From: raoulvdberge Date: Sun, 24 Nov 2024 23:08:55 +0100 Subject: [PATCH] feat: chemical storage disks And support in the grid and storage monitor. --- CHANGELOG.md | 6 + build.gradle.kts | 9 ++ gradle.properties | 1 + .../mekanism/ClientModInitializer.java | 23 ++++ .../refinedstorage/mekanism/Items.java | 37 +++++ .../MekanismIntegrationIdentifierUtil.java | 30 ++++ .../refinedstorage/mekanism/MekanismUtil.java | 15 ++ .../mekanism/ModInitializer.java | 111 +++++++++++++-- .../ChemicalGridExtractionStrategy.java | 66 +++++++++ .../chemical/ChemicalGridInsertionHint.java | 33 +++++ .../ChemicalGridInsertionStrategy.java | 70 ++++++++++ .../chemical/ChemicalGridResource.java | 130 ++++++++++++++++++ .../chemical/ChemicalGridResourceFactory.java | 75 ++++++++++ .../mekanism/chemical/ChemicalRenderer.java | 110 +++++++++++++++ .../mekanism/chemical/ChemicalResource.java | 45 ++++++ ...emicalResourceContainerInsertStrategy.java | 46 +++++++ .../chemical/ChemicalResourceFactory.java | 26 ++++ .../chemical/ChemicalResourceRendering.java | 86 ++++++++++++ .../chemical/ChemicalResourceType.java | 116 ++++++++++++++++ .../chemical/ChemicalStorageDiskItem.java | 95 +++++++++++++ ...emicalStorageMonitorInsertionStrategy.java | 82 +++++++++++ .../chemical/ChemicalStorageVariant.java | 74 ++++++++++ .../mekanism/chemical/package-info.java | 7 + .../lang/en_us.json | 14 ++ .../item/1024b_chemical_storage_disk.json | 6 + .../item/1024b_chemical_storage_part.json | 6 + .../item/256b_chemical_storage_disk.json | 6 + .../item/256b_chemical_storage_part.json | 1 + .../item/64b_chemical_storage_disk.json | 6 + .../item/64b_chemical_storage_part.json | 1 + .../item/8192b_chemical_storage_disk.json | 1 + .../item/8192b_chemical_storage_part.json | 1 + .../item/creative_chemical_storage_disk.json | 6 + .../gui/sprites/chemical_resource_type.png | Bin 0 -> 407 bytes .../item/1024b_chemical_storage_disk.png | Bin 0 -> 3147 bytes .../item/1024b_chemical_storage_part.png | Bin 0 -> 4017 bytes .../item/256b_chemical_storage_disk.png | Bin 0 -> 3148 bytes .../item/256b_chemical_storage_part.png | Bin 0 -> 3978 bytes .../item/64b_chemical_storage_disk.png | Bin 0 -> 3150 bytes .../item/64b_chemical_storage_part.png | Bin 0 -> 4001 bytes .../item/8192b_chemical_storage_disk.png | Bin 0 -> 3149 bytes .../item/8192b_chemical_storage_part.png | Bin 0 -> 4145 bytes .../item/creative_chemical_storage_disk.png | Bin 0 -> 3431 bytes .../advancement/storing_chemicals.json | 26 ++++ .../recipe/1024b_chemical_storage_disk.json | 25 ++++ ...cal_storage_disk_from_storage_housing.json | 14 ++ .../1024b_chemical_storage_disk_upgrade.json | 4 + .../recipe/1024b_chemical_storage_part.json | 25 ++++ .../recipe/256b_chemical_storage_disk.json | 25 ++++ ...cal_storage_disk_from_storage_housing.json | 14 ++ .../256b_chemical_storage_disk_upgrade.json | 4 + .../recipe/256b_chemical_storage_part.json | 25 ++++ .../recipe/64b_chemical_storage_disk.json | 25 ++++ ...cal_storage_disk_from_storage_housing.json | 14 ++ .../recipe/64b_chemical_storage_part.json | 25 ++++ .../recipe/8192b_chemical_storage_disk.json | 25 ++++ ...cal_storage_disk_from_storage_housing.json | 14 ++ .../8192b_chemical_storage_disk_upgrade.json | 4 + .../recipe/8192b_chemical_storage_part.json | 25 ++++ .../tags/item/chemical_storage_disks.json | 9 ++ 60 files changed, 1632 insertions(+), 12 deletions(-) create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/ClientModInitializer.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/Items.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/MekanismIntegrationIdentifierUtil.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/MekanismUtil.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridExtractionStrategy.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridInsertionHint.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridInsertionStrategy.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridResource.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridResourceFactory.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalRenderer.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResource.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceContainerInsertStrategy.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceFactory.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceRendering.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceType.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalStorageDiskItem.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalStorageMonitorInsertionStrategy.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalStorageVariant.java create mode 100644 src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/package-info.java create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/models/item/1024b_chemical_storage_disk.json create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/models/item/1024b_chemical_storage_part.json create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/models/item/256b_chemical_storage_disk.json create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/models/item/256b_chemical_storage_part.json create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/models/item/64b_chemical_storage_disk.json create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/models/item/64b_chemical_storage_part.json create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/models/item/8192b_chemical_storage_disk.json create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/models/item/8192b_chemical_storage_part.json create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/models/item/creative_chemical_storage_disk.json create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/textures/gui/sprites/chemical_resource_type.png create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/1024b_chemical_storage_disk.png create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/1024b_chemical_storage_part.png create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/256b_chemical_storage_disk.png create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/256b_chemical_storage_part.png create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/64b_chemical_storage_disk.png create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/64b_chemical_storage_part.png create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/8192b_chemical_storage_disk.png create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/8192b_chemical_storage_part.png create mode 100644 src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/creative_chemical_storage_disk.png create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/advancement/storing_chemicals.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_disk.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_disk_from_storage_housing.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_disk_upgrade.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_part.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_disk.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_disk_from_storage_housing.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_disk_upgrade.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_part.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/64b_chemical_storage_disk.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/64b_chemical_storage_disk_from_storage_housing.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/64b_chemical_storage_part.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_disk.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_disk_from_storage_housing.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_disk_upgrade.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_part.json create mode 100644 src/main/resources/data/refinedstorage_mekanism_integration/tags/item/chemical_storage_disks.json diff --git a/CHANGELOG.md b/CHANGELOG.md index 89e18ec..3560b59 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,3 +6,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ## Unreleased + +## Added + +- Chemical Storage Disk +- Chemical support in the Grid. +- Chemical support in the Storage Monitor. diff --git a/build.gradle.kts b/build.gradle.kts index 6db3797..06a3c73 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -18,6 +18,10 @@ repositories { includeGroup("mekanism") } } + maven { + name = "JEI" + url = uri("https://maven.blamejared.com/") + } } refinedarchitect { @@ -38,6 +42,7 @@ base { val refinedstorageVersion: String by project val minecraftVersion: String by project val mekanismVersion: String by project +val jeiVersion: String by project dependencies { api("com.refinedmods.refinedstorage:refinedstorage-neoforge:${refinedstorageVersion}") @@ -45,5 +50,9 @@ dependencies { runtimeOnly("mekanism:Mekanism:${minecraftVersion}-${mekanismVersion}:all") { exclude(group = "com.blamejared.crafttweaker") } + runtimeOnly("mezz.jei:jei-${minecraftVersion}-neoforge:${jeiVersion}") + compileOnlyApi("mezz.jei:jei-${minecraftVersion}-common-api:${jeiVersion}") + testCompileOnly("mezz.jei:jei-${minecraftVersion}-common:${jeiVersion}") + compileOnlyApi("mezz.jei:jei-${minecraftVersion}-neoforge-api:${jeiVersion}") } diff --git a/gradle.properties b/gradle.properties index 3e79821..87129a5 100644 --- a/gradle.properties +++ b/gradle.properties @@ -2,6 +2,7 @@ refinedarchitectVersion=0.20.0 refinedstorageVersion=2.0.0-milestone.4.10 # https://www.curseforge.com/minecraft/mc-mods/mekanism/files/all mekanismVersion=10.7.7.64 +jeiVersion=19.20.0.241 minecraftVersion=1.21.1 # Gradle org.gradle.jvmargs=-Xmx1G diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/ClientModInitializer.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/ClientModInitializer.java new file mode 100644 index 0000000..c1f5280 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/ClientModInitializer.java @@ -0,0 +1,23 @@ +package com.refinedmods.refinedstorage.mekanism; + +import com.refinedmods.refinedstorage.common.api.RefinedStorageApi; +import com.refinedmods.refinedstorage.mekanism.chemical.ChemicalGridInsertionHint; +import com.refinedmods.refinedstorage.mekanism.chemical.ChemicalResource; +import com.refinedmods.refinedstorage.mekanism.chemical.ChemicalResourceRendering; + +import net.neoforged.bus.api.SubscribeEvent; +import net.neoforged.fml.event.lifecycle.FMLClientSetupEvent; + +public final class ClientModInitializer { + private ClientModInitializer() { + } + + @SubscribeEvent + public static void onClientSetup(final FMLClientSetupEvent e) { + RefinedStorageApi.INSTANCE.registerResourceRendering( + ChemicalResource.class, + new ChemicalResourceRendering() + ); + RefinedStorageApi.INSTANCE.addAlternativeGridInsertionHint(new ChemicalGridInsertionHint()); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/Items.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/Items.java new file mode 100644 index 0000000..4f910e7 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/Items.java @@ -0,0 +1,37 @@ +package com.refinedmods.refinedstorage.mekanism; + +import com.refinedmods.refinedstorage.mekanism.chemical.ChemicalStorageVariant; + +import java.util.EnumMap; +import java.util.Map; +import java.util.function.Supplier; + +import net.minecraft.world.item.Item; + +public final class Items { + public static final Items INSTANCE = new Items(); + + private final Map> chemicalStorageParts = + new EnumMap<>(ChemicalStorageVariant.class); + private final Map> chemicalStorageDisks = + new EnumMap<>(ChemicalStorageVariant.class); + + private Items() { + } + + public Item getChemicalStoragePart(final ChemicalStorageVariant variant) { + return chemicalStorageParts.get(variant).get(); + } + + public void setChemicalStoragePart(final ChemicalStorageVariant variant, final Supplier supplier) { + chemicalStorageParts.put(variant, supplier); + } + + public Item getChemicalStorageDisk(final ChemicalStorageVariant variant) { + return chemicalStorageDisks.get(variant).get(); + } + + public void setChemicalStorageDisk(final ChemicalStorageVariant variant, final Supplier supplier) { + chemicalStorageDisks.put(variant, supplier); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/MekanismIntegrationIdentifierUtil.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/MekanismIntegrationIdentifierUtil.java new file mode 100644 index 0000000..45f3da5 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/MekanismIntegrationIdentifierUtil.java @@ -0,0 +1,30 @@ +package com.refinedmods.refinedstorage.mekanism; + +import net.minecraft.network.chat.Component; +import net.minecraft.network.chat.MutableComponent; +import net.minecraft.resources.ResourceLocation; + +public final class MekanismIntegrationIdentifierUtil { + public static final String MOD_ID = "refinedstorage_mekanism_integration"; + + private MekanismIntegrationIdentifierUtil() { + } + + public static ResourceLocation createMekanismIntegrationIdentifier(final String value) { + return ResourceLocation.fromNamespaceAndPath(MOD_ID, value); + } + + public static String createMekanismIntegrationTranslationKey(final String category, final String value) { + return String.format("%s.%s.%s", category, MOD_ID, value); + } + + public static MutableComponent createMekanismIntegrationTranslation(final String category, final String value) { + return Component.translatable(createMekanismIntegrationTranslationKey(category, value)); + } + + public static MutableComponent createMekanismIntegrationTranslation(final String category, + final String value, + final Object... args) { + return Component.translatable(createMekanismIntegrationTranslationKey(category, value), args); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/MekanismUtil.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/MekanismUtil.java new file mode 100644 index 0000000..071c58b --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/MekanismUtil.java @@ -0,0 +1,15 @@ +package com.refinedmods.refinedstorage.mekanism; + +import com.refinedmods.refinedstorage.api.core.Action; + +public final class MekanismUtil { + private MekanismUtil() { + } + + public static mekanism.api.Action toMekanismAction(final Action action) { + return switch (action) { + case EXECUTE -> mekanism.api.Action.EXECUTE; + case SIMULATE -> mekanism.api.Action.SIMULATE; + }; + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/ModInitializer.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/ModInitializer.java index 3106b19..e7aaa20 100644 --- a/src/main/java/com/refinedmods/refinedstorage/mekanism/ModInitializer.java +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/ModInitializer.java @@ -1,24 +1,111 @@ package com.refinedmods.refinedstorage.mekanism; -import com.refinedmods.refinedstorage.common.util.IdentifierUtil; +import com.refinedmods.refinedstorage.common.api.RefinedStorageApi; +import com.refinedmods.refinedstorage.common.storage.StorageContainerUpgradeRecipe; +import com.refinedmods.refinedstorage.common.storage.StorageContainerUpgradeRecipeSerializer; +import com.refinedmods.refinedstorage.common.support.SimpleItem; +import com.refinedmods.refinedstorage.mekanism.chemical.ChemicalGridExtractionStrategy; +import com.refinedmods.refinedstorage.mekanism.chemical.ChemicalGridInsertionStrategy; +import com.refinedmods.refinedstorage.mekanism.chemical.ChemicalResourceContainerInsertStrategy; +import com.refinedmods.refinedstorage.mekanism.chemical.ChemicalResourceFactory; +import com.refinedmods.refinedstorage.mekanism.chemical.ChemicalResourceType; +import com.refinedmods.refinedstorage.mekanism.chemical.ChemicalStorageDiskItem; +import com.refinedmods.refinedstorage.mekanism.chemical.ChemicalStorageMonitorInsertionStrategy; +import com.refinedmods.refinedstorage.mekanism.chemical.ChemicalStorageVariant; -import mekanism.api.MekanismAPI; +import net.minecraft.core.registries.BuiltInRegistries; +import net.minecraft.core.registries.Registries; +import net.minecraft.resources.ResourceKey; +import net.minecraft.world.item.CreativeModeTab; +import net.minecraft.world.item.Item; +import net.minecraft.world.item.crafting.RecipeSerializer; +import net.neoforged.api.distmarker.Dist; import net.neoforged.bus.api.IEventBus; import net.neoforged.fml.common.Mod; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import net.neoforged.fml.event.lifecycle.FMLCommonSetupEvent; +import net.neoforged.fml.loading.FMLEnvironment; +import net.neoforged.neoforge.event.BuildCreativeModeTabContentsEvent; +import net.neoforged.neoforge.registries.DeferredRegister; -@Mod(ModInitializer.ID) +import static com.refinedmods.refinedstorage.mekanism.MekanismIntegrationIdentifierUtil.createMekanismIntegrationIdentifier; + +@Mod(MekanismIntegrationIdentifierUtil.MOD_ID) public final class ModInitializer { - public static final String ID = "refinedstorage_mekanism_integration"; + public ModInitializer(final IEventBus eventBus) { + if (FMLEnvironment.dist == Dist.CLIENT) { + eventBus.addListener(ClientModInitializer::onClientSetup); + } + eventBus.addListener(this::setup); + eventBus.addListener(this::registerCreativeModeTabListener); - private static final Logger LOGGER = LoggerFactory.getLogger(ModInitializer.class); + final DeferredRegister itemRegistry = DeferredRegister.create( + BuiltInRegistries.ITEM, + MekanismIntegrationIdentifierUtil.MOD_ID + ); + for (final ChemicalStorageVariant variant : ChemicalStorageVariant.values()) { + if (variant.getStoragePartId() != null) { + Items.INSTANCE.setChemicalStoragePart( + variant, + itemRegistry.register(variant.getStoragePartId().getPath(), SimpleItem::new) + ); + } + Items.INSTANCE.setChemicalStorageDisk( + variant, + itemRegistry.register(variant.getStorageDiskId().getPath(), () -> new ChemicalStorageDiskItem( + RefinedStorageApi.INSTANCE.getStorageContainerItemHelper(), + variant + )) + ); + } + itemRegistry.register(eventBus); - public ModInitializer(final IEventBus eventBus) { - LOGGER.info( - "Refined Storage - Mekanism Integration has loaded. RS2 ModId: {}, Mekanism API version: {}", - IdentifierUtil.MOD_ID, - MekanismAPI.API_VERSION + final DeferredRegister> recipeSerializerRegistry = DeferredRegister.create( + BuiltInRegistries.RECIPE_SERIALIZER, + MekanismIntegrationIdentifierUtil.MOD_ID + ); + recipeSerializerRegistry.register( + "chemical_storage_disk_upgrade", + () -> new StorageContainerUpgradeRecipeSerializer<>( + ChemicalStorageVariant.values(), + to -> new StorageContainerUpgradeRecipe<>( + ChemicalStorageVariant.values(), to, Items.INSTANCE::getChemicalStorageDisk + ) + ) + ); + recipeSerializerRegistry.register(eventBus); + } + + private void setup(final FMLCommonSetupEvent e) { + RefinedStorageApi.INSTANCE.getResourceTypeRegistry().register( + createMekanismIntegrationIdentifier("chemical"), + ChemicalResourceType.INSTANCE + ); + RefinedStorageApi.INSTANCE.getAlternativeResourceFactories().add(new ChemicalResourceFactory()); + RefinedStorageApi.INSTANCE.getStorageTypeRegistry().register( + createMekanismIntegrationIdentifier("chemical"), + ChemicalResourceType.STORAGE_TYPE + ); + RefinedStorageApi.INSTANCE.addGridInsertionStrategyFactory(ChemicalGridInsertionStrategy::new); + RefinedStorageApi.INSTANCE.addGridExtractionStrategyFactory(ChemicalGridExtractionStrategy::new); + RefinedStorageApi.INSTANCE.addStorageMonitorInsertionStrategy(new ChemicalStorageMonitorInsertionStrategy()); + RefinedStorageApi.INSTANCE.addResourceContainerInsertStrategy(new ChemicalResourceContainerInsertStrategy()); + } + + private void registerCreativeModeTabListener(final BuildCreativeModeTabContentsEvent e) { + final ResourceKey creativeModeTab = ResourceKey.create( + Registries.CREATIVE_MODE_TAB, + RefinedStorageApi.INSTANCE.getCreativeModeTabId() ); + if (!e.getTabKey().equals(creativeModeTab)) { + return; + } + for (final ChemicalStorageVariant variant : ChemicalStorageVariant.values()) { + if (variant.getStoragePartId() != null) { + e.accept(Items.INSTANCE.getChemicalStoragePart(variant)); + } + } + for (final ChemicalStorageVariant variant : ChemicalStorageVariant.values()) { + e.accept(Items.INSTANCE.getChemicalStorageDisk(variant)); + } } } diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridExtractionStrategy.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridExtractionStrategy.java new file mode 100644 index 0000000..dafb1fb --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridExtractionStrategy.java @@ -0,0 +1,66 @@ +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.refinedmods.refinedstorage.api.grid.operations.GridExtractMode; +import com.refinedmods.refinedstorage.api.grid.operations.GridOperations; +import com.refinedmods.refinedstorage.common.api.grid.Grid; +import com.refinedmods.refinedstorage.common.api.grid.strategy.GridExtractionStrategy; +import com.refinedmods.refinedstorage.common.api.support.resource.PlatformResourceKey; + +import javax.annotation.Nullable; + +import mekanism.api.chemical.Chemical; +import mekanism.api.chemical.ChemicalStack; +import mekanism.api.chemical.IChemicalHandler; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.inventory.AbstractContainerMenu; +import net.minecraft.world.item.ItemStack; + +import static com.refinedmods.refinedstorage.mekanism.MekanismUtil.toMekanismAction; + +public class ChemicalGridExtractionStrategy implements GridExtractionStrategy { + private final AbstractContainerMenu menu; + private final GridOperations gridOperations; + + public ChemicalGridExtractionStrategy(final AbstractContainerMenu containerMenu, + final ServerPlayer player, + final Grid grid) { + this.menu = containerMenu; + this.gridOperations = grid.createOperations(ChemicalResourceType.INSTANCE, player); + } + + @Override + public boolean onExtract(final PlatformResourceKey resource, + final GridExtractMode extractMode, + final boolean cursor) { + if (resource instanceof ChemicalResource chemicalResource && isChemicalContainerOnCursor()) { + extractWithContainerOnCursor(chemicalResource, extractMode); + return true; + } + return false; + } + + @Nullable + private IChemicalHandler getChemicalStorage(final ItemStack stack) { + return stack.getCapability(ChemicalResourceType.ITEM_CAPABILITY); + } + + private void extractWithContainerOnCursor(final ChemicalResource chemicalResource, + final GridExtractMode mode) { + gridOperations.extract(chemicalResource, mode, (resource, amount, action, source) -> { + if (!(resource instanceof ChemicalResource(Chemical chemical))) { + return 0; + } + final IChemicalHandler destination = getChemicalStorage(menu.getCarried()); + if (destination == null) { + return 0; + } + final ChemicalStack toInsert = new ChemicalStack(chemical, amount); + final ChemicalStack remainder = destination.insertChemical(toInsert, toMekanismAction(action)); + return amount - remainder.getAmount(); + }); + } + + private boolean isChemicalContainerOnCursor() { + return getChemicalStorage(menu.getCarried()) != null; + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridInsertionHint.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridInsertionHint.java new file mode 100644 index 0000000..d893769 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridInsertionHint.java @@ -0,0 +1,33 @@ +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.refinedmods.refinedstorage.common.Platform; +import com.refinedmods.refinedstorage.common.api.RefinedStorageApi; +import com.refinedmods.refinedstorage.common.api.grid.GridInsertionHint; +import com.refinedmods.refinedstorage.common.support.tooltip.MouseClientTooltipComponent; + +import java.util.Optional; + +import mekanism.api.Action; +import mekanism.api.chemical.ChemicalStack; +import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent; +import net.minecraft.world.item.ItemStack; + +import static com.refinedmods.refinedstorage.mekanism.chemical.ChemicalResource.ofChemicalStack; + +public class ChemicalGridInsertionHint implements GridInsertionHint { + @Override + public Optional getHint(final ItemStack stack) { + return Optional.ofNullable(stack.getCapability(ChemicalResourceType.ITEM_CAPABILITY)) + .map(handler -> handler.extractChemical(Long.MAX_VALUE, Action.SIMULATE)) + .filter(result -> !result.isEmpty()) + .map(this::createComponent); + } + + private ClientTooltipComponent createComponent(final ChemicalStack result) { + final ChemicalResource chemicalResource = ofChemicalStack(result); + final String amount = result.getAmount() == Platform.INSTANCE.getBucketAmount() + ? null + : RefinedStorageApi.INSTANCE.getResourceRendering(ChemicalResource.class).formatAmount(result.getAmount()); + return MouseClientTooltipComponent.resource(MouseClientTooltipComponent.Type.RIGHT, chemicalResource, amount); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridInsertionStrategy.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridInsertionStrategy.java new file mode 100644 index 0000000..c5156b9 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridInsertionStrategy.java @@ -0,0 +1,70 @@ +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.refinedmods.refinedstorage.api.grid.operations.GridInsertMode; +import com.refinedmods.refinedstorage.api.grid.operations.GridOperations; +import com.refinedmods.refinedstorage.common.api.grid.Grid; +import com.refinedmods.refinedstorage.common.api.grid.strategy.GridInsertionStrategy; + +import javax.annotation.Nullable; + +import mekanism.api.chemical.Chemical; +import mekanism.api.chemical.ChemicalStack; +import mekanism.api.chemical.IChemicalHandler; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.inventory.AbstractContainerMenu; +import net.minecraft.world.item.ItemStack; + +import static com.refinedmods.refinedstorage.mekanism.MekanismUtil.toMekanismAction; +import static com.refinedmods.refinedstorage.mekanism.chemical.ChemicalResource.ofChemicalStack; + +public class ChemicalGridInsertionStrategy implements GridInsertionStrategy { + private final AbstractContainerMenu menu; + private final GridOperations gridOperations; + + public ChemicalGridInsertionStrategy(final AbstractContainerMenu menu, + final ServerPlayer player, + final Grid grid) { + this.menu = menu; + this.gridOperations = grid.createOperations(ChemicalResourceType.INSTANCE, player); + } + + @Override + public boolean onInsert(final GridInsertMode insertMode, final boolean tryAlternatives) { + final IChemicalHandler cursorStorage = getChemicalCursorStorage(); + if (cursorStorage == null) { + return false; + } + if (cursorStorage.getChemicalTanks() == 0) { + return false; + } + final ChemicalStack extractableResource = cursorStorage.getChemicalInTank(0); + if (extractableResource.isEmpty()) { + return false; + } + final ChemicalResource chemicalResource = ofChemicalStack(extractableResource); + gridOperations.insert(chemicalResource, insertMode, (resource, amount, action, source) -> { + if (!(resource instanceof ChemicalResource(Chemical chemical))) { + return 0; + } + final ChemicalStack toDrain = new ChemicalStack(chemical, amount); + final ChemicalStack drained = cursorStorage.extractChemical(toDrain, toMekanismAction(action)); + return drained.getAmount(); + }); + return true; + } + + @Nullable + private IChemicalHandler getChemicalCursorStorage() { + return getChemicalStorage(menu.getCarried()); + } + + @Nullable + private IChemicalHandler getChemicalStorage(final ItemStack stack) { + return stack.getCapability(ChemicalResourceType.ITEM_CAPABILITY); + } + + @Override + public boolean onTransfer(final int slotIndex) { + throw new UnsupportedOperationException(); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridResource.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridResource.java new file mode 100644 index 0000000..ea5194a --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridResource.java @@ -0,0 +1,130 @@ +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.refinedmods.refinedstorage.api.grid.operations.GridExtractMode; +import com.refinedmods.refinedstorage.api.grid.view.GridResourceAttributeKey; +import com.refinedmods.refinedstorage.api.grid.view.GridView; +import com.refinedmods.refinedstorage.api.resource.ResourceAmount; +import com.refinedmods.refinedstorage.common.Platform; +import com.refinedmods.refinedstorage.common.api.RefinedStorageApi; +import com.refinedmods.refinedstorage.common.api.grid.GridScrollMode; +import com.refinedmods.refinedstorage.common.api.grid.strategy.GridExtractionStrategy; +import com.refinedmods.refinedstorage.common.api.grid.strategy.GridScrollingStrategy; +import com.refinedmods.refinedstorage.common.api.grid.view.AbstractPlatformGridResource; +import com.refinedmods.refinedstorage.common.api.support.resource.ResourceRendering; +import com.refinedmods.refinedstorage.common.api.support.resource.ResourceType; +import com.refinedmods.refinedstorage.common.support.tooltip.MouseClientTooltipComponent; + +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import javax.annotation.Nullable; + +import mekanism.api.Action; +import mekanism.api.MekanismAPI; +import mekanism.api.chemical.ChemicalStack; +import net.minecraft.client.gui.GuiGraphics; +import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent; +import net.minecraft.network.chat.Component; +import net.minecraft.world.inventory.tooltip.TooltipComponent; +import net.minecraft.world.item.ItemStack; + +public class ChemicalGridResource extends AbstractPlatformGridResource { + private final int id; + private final ResourceRendering rendering; + private final List tooltip; + + public ChemicalGridResource(final ChemicalResource resource, + final String name, + final Map> attributes, + final boolean autocraftable) { + super(resource, name, attributes, autocraftable); + this.id = MekanismAPI.CHEMICAL_REGISTRY.getId(resource.chemical()); + this.rendering = RefinedStorageApi.INSTANCE.getResourceRendering(ChemicalResource.class); + this.tooltip = List.of(resource.chemical().getTextComponent()); + } + + @Override + public int getRegistryId() { + return id; + } + + @Override + public List getExtractionHints(final ItemStack carriedStack, final GridView view) { + final ItemStack modifiedStack = carriedStack.copy(); + return Optional.ofNullable(modifiedStack.getCapability(ChemicalResourceType.ITEM_CAPABILITY)) + .map(handler -> handler.insertChemical( + new ChemicalStack(resource.chemical(), Platform.INSTANCE.getBucketAmount()), + Action.EXECUTE + )) + .filter(remainder -> remainder.getAmount() != Platform.INSTANCE.getBucketAmount()) + .map(remainder -> MouseClientTooltipComponent.item( + MouseClientTooltipComponent.Type.LEFT, + modifiedStack, + null + )).stream().toList(); + } + + @Nullable + @Override + public ResourceAmount getAutocraftingRequest() { + return new ResourceAmount(resource, Platform.INSTANCE.getBucketAmount()); + } + + @Override + public boolean canExtract(final ItemStack carriedStack, final GridView view) { + if (getAmount(view) == 0) { + return false; + } + if (carriedStack.isEmpty()) { + return true; + } + final ChemicalStack toFill = new ChemicalStack(resource.chemical(), view.getAmount(resource)); + return Optional.ofNullable(carriedStack.getCapability(ChemicalResourceType.ITEM_CAPABILITY)) + .map(handler -> handler.insertChemical(toFill, Action.SIMULATE)) + .map(remainder -> remainder.getAmount() != toFill.getAmount()) + .orElse(false); + } + + @Override + public void onExtract(final GridExtractMode extractMode, + final boolean cursor, + final GridExtractionStrategy extractionStrategy) { + extractionStrategy.onExtract(resource, extractMode, cursor); + } + + @Override + public void onScroll(final GridScrollMode scrollMode, final GridScrollingStrategy scrollingStrategy) { + // no-op + } + + @Override + public void render(final GuiGraphics graphics, final int x, final int y) { + ChemicalRenderer.render(graphics.pose(), x, y, resource.chemical()); + } + + @Override + public String getDisplayedAmount(final GridView view) { + return rendering.formatAmount(getAmount(view), true); + } + + @Override + public String getAmountInTooltip(final GridView view) { + return rendering.formatAmount(getAmount(view)); + } + + @Override + public boolean belongsToResourceType(final ResourceType resourceType) { + return resourceType == ChemicalResourceType.INSTANCE; + } + + @Override + public List getTooltip() { + return tooltip; + } + + @Override + public Optional getTooltipImage() { + return Optional.empty(); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridResourceFactory.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridResourceFactory.java new file mode 100644 index 0000000..0fb446d --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalGridResourceFactory.java @@ -0,0 +1,75 @@ +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.refinedmods.refinedstorage.api.grid.view.GridResource; +import com.refinedmods.refinedstorage.api.grid.view.GridResourceFactory; +import com.refinedmods.refinedstorage.api.resource.ResourceKey; +import com.refinedmods.refinedstorage.common.api.grid.GridResourceAttributeKeys; + +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; + +import mekanism.api.MekanismAPI; +import mekanism.api.chemical.Chemical; +import net.minecraft.core.Holder; +import net.neoforged.fml.ModList; + +public class ChemicalGridResourceFactory implements GridResourceFactory { + public static final ChemicalGridResourceFactory INSTANCE = new ChemicalGridResourceFactory(); + + private ChemicalGridResourceFactory() { + } + + @Override + public Optional apply(final ResourceKey resource, final boolean autocraftable) { + if (!(resource instanceof ChemicalResource chemicalResource)) { + return Optional.empty(); + } + final String name = getName(chemicalResource); + final String modId = getModId(chemicalResource); + final String modName = getModName(modId); + final Set tags = getTags(chemicalResource.chemical()); + final String tooltip = getTooltip(chemicalResource); + return Optional.of(new ChemicalGridResource( + chemicalResource, + name, + Map.of( + GridResourceAttributeKeys.MOD_ID, Set.of(modId), + GridResourceAttributeKeys.MOD_NAME, Set.of(modName), + GridResourceAttributeKeys.TAGS, tags, + GridResourceAttributeKeys.TOOLTIP, Set.of(tooltip) + ), + autocraftable + )); + } + + private Set getTags(final Chemical chemical) { + return MekanismAPI.CHEMICAL_REGISTRY.getResourceKey(chemical) + .flatMap(MekanismAPI.CHEMICAL_REGISTRY::getHolder) + .stream() + .flatMap(Holder::tags) + .map(tagKey -> tagKey.location().getPath()) + .collect(Collectors.toSet()); + } + + private String getModId(final ChemicalResource chemical) { + return MekanismAPI.CHEMICAL_REGISTRY.getKey(chemical.chemical()).getNamespace(); + } + + private String getTooltip(final ChemicalResource resource) { + return getName(resource); + } + + private String getModName(final String modId) { + return ModList + .get() + .getModContainerById(modId) + .map(container -> container.getModInfo().getDisplayName()) + .orElse(""); + } + + private String getName(final ChemicalResource chemical) { + return chemical.chemical().getTextComponent().getString(); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalRenderer.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalRenderer.java new file mode 100644 index 0000000..5477f93 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalRenderer.java @@ -0,0 +1,110 @@ +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.BufferBuilder; +import com.mojang.blaze3d.vertex.BufferUploader; +import com.mojang.blaze3d.vertex.DefaultVertexFormat; +import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.blaze3d.vertex.Tesselator; +import com.mojang.blaze3d.vertex.VertexConsumer; +import com.mojang.blaze3d.vertex.VertexFormat; +import mekanism.api.chemical.Chemical; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.GameRenderer; +import net.minecraft.client.renderer.MultiBufferSource; +import net.minecraft.client.renderer.RenderType; +import net.minecraft.client.renderer.texture.OverlayTexture; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.inventory.InventoryMenu; + +public final class ChemicalRenderer { + private ChemicalRenderer() { + } + + public static void render(final PoseStack poseStack, final int x, final int y, final Chemical chemical) { + final int packedRgb = chemical.getTint(); + final Minecraft minecraft = Minecraft.getInstance(); + final ResourceLocation icon = chemical.getIcon(); + final TextureAtlasSprite sprite = minecraft.getTextureAtlas(InventoryMenu.BLOCK_ATLAS).apply(icon); + render(poseStack, x, y, packedRgb, sprite); + } + + public static void render(final PoseStack poseStack, + final MultiBufferSource renderTypeBuffer, + final int light, + final Chemical chemical) { + final int packedRgb = chemical.getTint(); + final Minecraft minecraft = Minecraft.getInstance(); + final ResourceLocation icon = chemical.getIcon(); + final TextureAtlasSprite sprite = minecraft.getTextureAtlas(InventoryMenu.BLOCK_ATLAS).apply(icon); + render(poseStack, renderTypeBuffer, light, packedRgb, sprite); + } + + private static void render(final PoseStack poseStack, + final int x, + final int y, + final int packedRgb, + final TextureAtlasSprite sprite) { + RenderSystem.setShaderTexture(0, sprite.atlasLocation()); + final int r = packedRgb >> 16 & 255; + final int g = packedRgb >> 8 & 255; + final int b = packedRgb & 255; + final int slotXEnd = x + 16; + final int slotYEnd = y + 16; + RenderSystem.setShader(GameRenderer::getPositionTexColorShader); + final Tesselator tesselator = Tesselator.getInstance(); + final BufferBuilder bufferBuilder = tesselator.begin( + VertexFormat.Mode.QUADS, + DefaultVertexFormat.POSITION_TEX_COLOR + ); + bufferBuilder.addVertex(poseStack.last().pose(), (float) x, (float) slotYEnd, 0.0F) + .setUv(sprite.getU0(), sprite.getV1()).setColor(r, g, b, 255); + bufferBuilder.addVertex(poseStack.last().pose(), (float) slotXEnd, (float) slotYEnd, 0.0F) + .setUv(sprite.getU1(), sprite.getV1()).setColor(r, g, b, 255); + bufferBuilder.addVertex(poseStack.last().pose(), (float) slotXEnd, (float) y, 0.0F) + .setUv(sprite.getU1(), sprite.getV0()).setColor(r, g, b, 255); + bufferBuilder.addVertex(poseStack.last().pose(), (float) x, (float) y, 0.0F) + .setUv(sprite.getU0(), sprite.getV0()).setColor(r, g, b, 255); + BufferUploader.drawWithShader(bufferBuilder.buildOrThrow()); + } + + private static void render(final PoseStack poseStack, + final MultiBufferSource buffers, + final int light, + final int packedRgb, + final TextureAtlasSprite sprite) { + final VertexConsumer buffer = buffers.getBuffer(RenderType.solid()); + final float scale = 0.3F; + // y is flipped here + final var x0 = -scale / 2; + final var y0 = scale / 2; + final var x1 = scale / 2; + final var y1 = -scale / 2; + final var transform = poseStack.last().pose(); + buffer.addVertex(transform, x0, y1, 0) + .setColor(packedRgb) + .setUv(sprite.getU0(), sprite.getV1()) + .setOverlay(OverlayTexture.NO_OVERLAY) + .setLight(light) + .setNormal(0, 0, 1); + buffer.addVertex(transform, x1, y1, 0) + .setColor(packedRgb) + .setUv(sprite.getU1(), sprite.getV1()) + .setOverlay(OverlayTexture.NO_OVERLAY) + .setLight(light) + .setNormal(0, 0, 1); + buffer.addVertex(transform, x1, y0, 0) + .setColor(packedRgb) + .setUv(sprite.getU1(), sprite.getV0()) + .setOverlay(OverlayTexture.NO_OVERLAY) + .setLight(light) + .setNormal(0, 0, 1); + buffer.addVertex(transform, x0, y0, 0) + .setColor(packedRgb) + .setUv(sprite.getU0(), sprite.getV0()) + .setOverlay(OverlayTexture.NO_OVERLAY) + .setLight(light) + .setNormal(0, 0, 1); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResource.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResource.java new file mode 100644 index 0000000..4c0827d --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResource.java @@ -0,0 +1,45 @@ +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.refinedmods.refinedstorage.common.Platform; +import com.refinedmods.refinedstorage.common.api.support.resource.PlatformResourceKey; +import com.refinedmods.refinedstorage.common.api.support.resource.ResourceTag; +import com.refinedmods.refinedstorage.common.api.support.resource.ResourceType; +import com.refinedmods.refinedstorage.common.support.resource.ResourceTypes; + +import java.util.List; + +import mekanism.api.MekanismAPI; +import mekanism.api.chemical.Chemical; +import mekanism.api.chemical.ChemicalStack; + +public record ChemicalResource(Chemical chemical) implements PlatformResourceKey { + public static ChemicalResource ofChemicalStack(final ChemicalStack stack) { + return new ChemicalResource(stack.getChemical()); + } + + @Override + public long getInterfaceExportLimit() { + return ResourceTypes.FLUID.getInterfaceExportLimit(); + } + + @Override + public long getProcessingPatternLimit() { + return Platform.INSTANCE.getBucketAmount() * 16; + } + + @Override + public List getTags() { + return MekanismAPI.CHEMICAL_REGISTRY.wrapAsHolder(chemical) + .tags() + .flatMap(tagKey -> MekanismAPI.CHEMICAL_REGISTRY.getTag(tagKey).stream()) + .map(tag -> new ResourceTag( + tag.key(), + tag.stream().map(holder -> (PlatformResourceKey) new ChemicalResource(holder.value())).toList() + )).toList(); + } + + @Override + public ResourceType getResourceType() { + return ChemicalResourceType.INSTANCE; + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceContainerInsertStrategy.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceContainerInsertStrategy.java new file mode 100644 index 0000000..38fdb2b --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceContainerInsertStrategy.java @@ -0,0 +1,46 @@ +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.refinedmods.refinedstorage.api.resource.ResourceAmount; +import com.refinedmods.refinedstorage.api.resource.ResourceKey; +import com.refinedmods.refinedstorage.common.Platform; +import com.refinedmods.refinedstorage.common.api.support.resource.ResourceContainerInsertStrategy; + +import java.util.Optional; + +import mekanism.api.Action; +import mekanism.api.chemical.Chemical; +import mekanism.api.chemical.ChemicalStack; +import net.minecraft.world.item.ItemStack; + +public class ChemicalResourceContainerInsertStrategy implements ResourceContainerInsertStrategy { + @Override + public Optional insert(final ItemStack container, final ResourceAmount resourceAmount) { + if (!(resourceAmount.resource() instanceof ChemicalResource(Chemical chemical))) { + return Optional.empty(); + } + final ItemStack modifiedContainer = container.copy(); + return Optional.ofNullable(modifiedContainer.getCapability(ChemicalResourceType.ITEM_CAPABILITY)) + .map(handler -> handler.insertChemical( + new ChemicalStack(chemical, resourceAmount.amount()), + Action.EXECUTE + )) + .map(remainder -> resourceAmount.amount() - remainder.getAmount()) + .map(inserted -> new InsertResult(modifiedContainer, inserted)); + } + + // TODO: IFace max is wrong! + @Override + public Optional getConversionInfo(final ResourceKey resource, final ItemStack carriedStack) { + if (!(resource instanceof ChemicalResource(Chemical chemical))) { + return Optional.empty(); + } + final ItemStack modifiedStack = carriedStack.copy(); + return Optional.ofNullable(modifiedStack.getCapability(ChemicalResourceType.ITEM_CAPABILITY)) + .map(handler -> handler.insertChemical( + new ChemicalStack(chemical, Platform.INSTANCE.getBucketAmount()), + Action.EXECUTE + )) + .filter(ChemicalStack::isEmpty) + .map(result -> new ConversionInfo(carriedStack, modifiedStack)); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceFactory.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceFactory.java new file mode 100644 index 0000000..b235e10 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceFactory.java @@ -0,0 +1,26 @@ +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.refinedmods.refinedstorage.api.resource.ResourceAmount; +import com.refinedmods.refinedstorage.api.resource.ResourceKey; +import com.refinedmods.refinedstorage.common.api.support.resource.ResourceFactory; + +import java.util.Optional; + +import mekanism.api.Action; +import net.minecraft.world.item.ItemStack; + +import static com.refinedmods.refinedstorage.mekanism.chemical.ChemicalResource.ofChemicalStack; + +public class ChemicalResourceFactory implements ResourceFactory { + @Override + public Optional create(final ItemStack stack) { + return Optional.ofNullable(stack.getCapability(ChemicalResourceType.ITEM_CAPABILITY)) + .map(handler -> handler.extractChemical(Long.MAX_VALUE, Action.SIMULATE)) + .map(chemicalStack -> new ResourceAmount(ofChemicalStack(chemicalStack), chemicalStack.getAmount())); + } + + @Override + public boolean isValid(final ResourceKey resourceKey) { + return resourceKey instanceof ChemicalResource; + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceRendering.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceRendering.java new file mode 100644 index 0000000..701949b --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceRendering.java @@ -0,0 +1,86 @@ +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.refinedmods.refinedstorage.api.resource.ResourceKey; +import com.refinedmods.refinedstorage.common.api.support.resource.ResourceRendering; +import com.refinedmods.refinedstorage.common.util.IdentifierUtil; + +import java.text.DecimalFormat; +import java.text.DecimalFormatSymbols; +import java.util.Collections; +import java.util.List; +import java.util.Locale; + +import com.mojang.blaze3d.vertex.PoseStack; +import mekanism.api.chemical.Chemical; +import net.minecraft.client.gui.GuiGraphics; +import net.minecraft.client.renderer.MultiBufferSource; +import net.minecraft.network.chat.Component; +import net.minecraft.world.level.Level; +import net.neoforged.neoforge.fluids.FluidType; + +public class ChemicalResourceRendering implements ResourceRendering { + private static final DecimalFormat LESS_THAN_1_BUCKET_FORMATTER; + private static final DecimalFormat FORMATTER; + + @Override + public String formatAmount(final long amount, final boolean withUnits) { + return !withUnits ? format(amount) : formatWithUnits(amount); + } + + @Override + public Component getDisplayName(final ResourceKey resourceKey) { + if (resourceKey instanceof ChemicalResource(Chemical chemical)) { + return chemical.getTextComponent(); + } + return Component.empty(); + } + + @Override + public List getTooltip(final ResourceKey resourceKey) { + if (resourceKey instanceof ChemicalResource(Chemical chemical)) { + return List.of(chemical.getTextComponent()); + } + return Collections.emptyList(); + } + + @Override + public void render(final ResourceKey resourceKey, final GuiGraphics graphics, final int x, final int y) { + if (resourceKey instanceof ChemicalResource(Chemical chemical)) { + ChemicalRenderer.render(graphics.pose(), x, y, chemical); + } + } + + @Override + public void render(final ResourceKey resourceKey, + final PoseStack poseStack, + final MultiBufferSource multiBufferSource, + final int light, + final Level level) { + if (resourceKey instanceof ChemicalResource(Chemical chemical)) { + ChemicalRenderer.render(poseStack, multiBufferSource, light, chemical); + } + } + + private static String formatWithUnits(final long mb) { + final double buckets = convertToBuckets(mb); + if (buckets >= 1) { + return IdentifierUtil.formatWithUnits((long) Math.floor(buckets)); + } else { + return LESS_THAN_1_BUCKET_FORMATTER.format(buckets); + } + } + + public static String format(final long mb) { + final double buckets = convertToBuckets(mb); + return FORMATTER.format(buckets); + } + + private static double convertToBuckets(final long mb) { + return mb / (double) FluidType.BUCKET_VOLUME; + } + + static { + LESS_THAN_1_BUCKET_FORMATTER = new DecimalFormat("0.#", DecimalFormatSymbols.getInstance(Locale.US)); + FORMATTER = new DecimalFormat("#,###.#", DecimalFormatSymbols.getInstance(Locale.US)); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceType.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceType.java new file mode 100644 index 0000000..6e341d5 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalResourceType.java @@ -0,0 +1,116 @@ +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.refinedmods.refinedstorage.api.grid.operations.GridOperations; +import com.refinedmods.refinedstorage.api.grid.operations.GridOperationsImpl; +import com.refinedmods.refinedstorage.api.grid.view.GridResource; +import com.refinedmods.refinedstorage.api.resource.ResourceKey; +import com.refinedmods.refinedstorage.api.storage.Actor; +import com.refinedmods.refinedstorage.api.storage.root.RootStorage; +import com.refinedmods.refinedstorage.common.Platform; +import com.refinedmods.refinedstorage.common.api.storage.StorageType; +import com.refinedmods.refinedstorage.common.api.support.resource.PlatformResourceKey; +import com.refinedmods.refinedstorage.common.api.support.resource.ResourceType; +import com.refinedmods.refinedstorage.common.storage.SameTypeStorageType; + +import java.util.Optional; + +import com.mojang.serialization.Codec; +import com.mojang.serialization.MapCodec; +import com.mojang.serialization.codecs.RecordCodecBuilder; +import mekanism.api.MekanismAPI; +import mekanism.api.chemical.Chemical; +import mekanism.api.chemical.IChemicalHandler; +import net.minecraft.network.RegistryFriendlyByteBuf; +import net.minecraft.network.chat.MutableComponent; +import net.minecraft.network.codec.StreamCodec; +import net.minecraft.resources.ResourceLocation; +import net.neoforged.neoforge.capabilities.ItemCapability; + +import static com.refinedmods.refinedstorage.mekanism.MekanismIntegrationIdentifierUtil.createMekanismIntegrationIdentifier; +import static com.refinedmods.refinedstorage.mekanism.MekanismIntegrationIdentifierUtil.createMekanismIntegrationTranslation; + +public class ChemicalResourceType implements ResourceType { + public static final ChemicalResourceType INSTANCE = new ChemicalResourceType(); + + public static final MapCodec MAP_CODEC = RecordCodecBuilder.mapCodec(ins -> ins.group( + Chemical.CODEC.fieldOf("chemical").forGetter(ChemicalResource::chemical) + ).apply(ins, ChemicalResource::new)); + public static final Codec CODEC = MAP_CODEC.codec(); + public static final StreamCodec STREAM_CODEC = StreamCodec.composite( + Chemical.STREAM_CODEC, ChemicalResource::chemical, + ChemicalResource::new + ); + public static final ItemCapability ITEM_CAPABILITY = ItemCapability.createVoid( + ResourceLocation.fromNamespaceAndPath(MekanismAPI.MEKANISM_MODID, "chemical_handler"), + IChemicalHandler.class + ); + public static final StorageType STORAGE_TYPE = new SameTypeStorageType<>( + CODEC, + resource -> resource instanceof ChemicalResource(Chemical chemical) + && !chemical.hasAttributesWithValidation(), + ChemicalResource.class::cast, + Platform.INSTANCE.getBucketAmount(), + Platform.INSTANCE.getBucketAmount() * 16 + ); + + private static final MutableComponent TITLE = createMekanismIntegrationTranslation( + "misc", + "resource_type.chemical" + ); + private static final ResourceLocation SPRITE = createMekanismIntegrationIdentifier("chemical_resource_type"); + + private ChemicalResourceType() { + } + + @Override + @SuppressWarnings({"unchecked", "rawtypes"}) + public MapCodec getMapCodec() { + return (MapCodec) MAP_CODEC; + } + + @Override + @SuppressWarnings({"unchecked", "rawtypes"}) + public StreamCodec getStreamCodec() { + return (StreamCodec) STREAM_CODEC; + } + + @Override + public MutableComponent getTitle() { + return TITLE; + } + + @Override + public ResourceLocation getSprite() { + return SPRITE; + } + + @Override + public long normalizeAmount(final double amount) { + return (long) (amount * Platform.INSTANCE.getBucketAmount()); + } + + @Override + public double getDisplayAmount(final long amount) { + return amount / (double) Platform.INSTANCE.getBucketAmount(); + } + + @Override + public Optional toGridResource(final ResourceKey resourceKey, final boolean autocraftable) { + return ChemicalGridResourceFactory.INSTANCE.apply(resourceKey, autocraftable); + } + + @Override + public long getInterfaceExportLimit() { + return Platform.INSTANCE.getBucketAmount() * 16; + } + + @Override + public GridOperations createGridOperations(final RootStorage rootStorage, final Actor actor) { + return new GridOperationsImpl( + rootStorage, + actor, + resource -> Long.MAX_VALUE, + Platform.INSTANCE.getBucketAmount() + ); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalStorageDiskItem.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalStorageDiskItem.java new file mode 100644 index 0000000..af4d1f7 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalStorageDiskItem.java @@ -0,0 +1,95 @@ +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.refinedmods.refinedstorage.common.api.storage.AbstractStorageContainerItem; +import com.refinedmods.refinedstorage.common.api.storage.SerializableStorage; +import com.refinedmods.refinedstorage.common.api.storage.StorageContainerItemHelper; +import com.refinedmods.refinedstorage.common.api.storage.StorageRepository; +import com.refinedmods.refinedstorage.common.api.support.HelpTooltipComponent; +import com.refinedmods.refinedstorage.common.storage.StorageVariant; +import com.refinedmods.refinedstorage.common.storage.UpgradeableStorageContainer; +import com.refinedmods.refinedstorage.mekanism.Items; + +import java.util.Optional; +import javax.annotation.Nullable; + +import net.minecraft.network.chat.Component; +import net.minecraft.world.inventory.tooltip.TooltipComponent; +import net.minecraft.world.item.Item; +import net.minecraft.world.item.ItemStack; + +import static com.refinedmods.refinedstorage.common.util.IdentifierUtil.format; +import static com.refinedmods.refinedstorage.mekanism.MekanismIntegrationIdentifierUtil.createMekanismIntegrationTranslation; + +public class ChemicalStorageDiskItem extends AbstractStorageContainerItem implements UpgradeableStorageContainer { + private static final Component CREATIVE_HELP = createMekanismIntegrationTranslation( + "item", + "creative_chemical_storage_disk.help" + ); + + private final ChemicalStorageVariant variant; + private final Component helpText; + + public ChemicalStorageDiskItem(final StorageContainerItemHelper helper, + final ChemicalStorageVariant variant) { + super(new Item.Properties().stacksTo(1).fireResistant(), helper); + this.variant = variant; + this.helpText = getHelpText(variant); + } + + private static Component getHelpText(final ChemicalStorageVariant variant) { + if (variant.getCapacityInBuckets() == null) { + return CREATIVE_HELP; + } + return createMekanismIntegrationTranslation( + "item", + "chemical_storage_disk.help", + format(variant.getCapacityInBuckets()) + ); + } + + + @Override + @Nullable + protected Long getCapacity() { + return variant.getCapacity(); + } + + @Override + protected String formatAmount(final long amount) { + return ChemicalResourceRendering.format(amount); + } + + @Override + protected SerializableStorage createStorage(final StorageRepository storageRepository) { + return ChemicalResourceType.STORAGE_TYPE.create(getCapacity(), storageRepository::markAsChanged); + } + + @Override + protected ItemStack createPrimaryDisassemblyByproduct(final int count) { + return new ItemStack(com.refinedmods.refinedstorage.common.content.Items.INSTANCE.getStorageHousing(), count); + } + + @Override + @Nullable + protected ItemStack createSecondaryDisassemblyByproduct(final int count) { + if (variant == ChemicalStorageVariant.CREATIVE) { + return null; + } + return new ItemStack(Items.INSTANCE.getChemicalStoragePart(variant), count); + } + + @Override + public Optional getTooltipImage(final ItemStack stack) { + return Optional.of(new HelpTooltipComponent(helpText)); + } + + @Override + public StorageVariant getVariant() { + return variant; + } + + @Override + public void transferTo(final ItemStack from, final ItemStack to) { + helper.markAsToTransfer(from, to); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalStorageMonitorInsertionStrategy.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalStorageMonitorInsertionStrategy.java new file mode 100644 index 0000000..3276917 --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalStorageMonitorInsertionStrategy.java @@ -0,0 +1,82 @@ +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.refinedmods.refinedstorage.api.core.Action; +import com.refinedmods.refinedstorage.api.network.Network; +import com.refinedmods.refinedstorage.api.network.storage.StorageNetworkComponent; +import com.refinedmods.refinedstorage.api.resource.ResourceKey; +import com.refinedmods.refinedstorage.api.storage.Actor; +import com.refinedmods.refinedstorage.api.storage.root.RootStorage; +import com.refinedmods.refinedstorage.common.api.storagemonitor.StorageMonitorInsertionStrategy; + +import java.util.Optional; +import javax.annotation.Nullable; + +import mekanism.api.chemical.ChemicalStack; +import mekanism.api.chemical.IChemicalHandler; +import net.minecraft.world.item.ItemStack; + +import static com.refinedmods.refinedstorage.mekanism.chemical.ChemicalResource.ofChemicalStack; + +public class ChemicalStorageMonitorInsertionStrategy implements StorageMonitorInsertionStrategy { + @Override + public Optional insert( + final ResourceKey configuredResource, + final ItemStack stack, + final Actor actor, + final Network network + ) { + if (!(configuredResource instanceof ChemicalResource configuredChemicalResource)) { + return Optional.empty(); + } + final RootStorage rootStorage = network.getComponent(StorageNetworkComponent.class); + final ItemStack modifiedStack = stack.copy(); + return Optional.ofNullable(modifiedStack.getCapability(ChemicalResourceType.ITEM_CAPABILITY)) + .map(handler -> handleInsert(actor, configuredChemicalResource, handler, rootStorage, modifiedStack)); + } + + @Nullable + private ItemStack handleInsert(final Actor actor, + final ChemicalResource configuredChemicalResource, + final IChemicalHandler handler, + final RootStorage rootStorage, + final ItemStack modifiedStack) { + final ChemicalStack extractedSimulated = handler.extractChemical(Long.MAX_VALUE, mekanism.api.Action.SIMULATE); + if (extractedSimulated.isEmpty()) { + return null; + } + final long insertedSimulated = tryInsert(actor, configuredChemicalResource, extractedSimulated, rootStorage); + if (insertedSimulated == 0) { + return null; + } + final ChemicalStack extracted = handler.extractChemical(insertedSimulated, mekanism.api.Action.EXECUTE); + if (extracted.isEmpty()) { + return null; + } + doInsert(actor, extracted, rootStorage); + return modifiedStack; + } + + private long tryInsert(final Actor actor, + final ChemicalResource configuredResource, + final ChemicalStack result, + final RootStorage rootStorage) { + if (!result.getChemical().equals(configuredResource.chemical())) { + return 0; + } + return rootStorage.insert( + ofChemicalStack(result), + result.getAmount(), + Action.SIMULATE, + actor + ); + } + + private void doInsert(final Actor actor, final ChemicalStack result, final RootStorage rootStorage) { + rootStorage.insert( + ofChemicalStack(result), + result.getAmount(), + Action.EXECUTE, + actor + ); + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalStorageVariant.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalStorageVariant.java new file mode 100644 index 0000000..91715cf --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/ChemicalStorageVariant.java @@ -0,0 +1,74 @@ +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.refinedmods.refinedstorage.common.Platform; +import com.refinedmods.refinedstorage.common.storage.StorageVariant; +import com.refinedmods.refinedstorage.mekanism.Items; + +import javax.annotation.Nullable; + +import net.minecraft.resources.ResourceLocation; +import net.minecraft.util.StringRepresentable; +import net.minecraft.world.item.Item; + +import static com.refinedmods.refinedstorage.mekanism.MekanismIntegrationIdentifierUtil.createMekanismIntegrationIdentifier; + +public enum ChemicalStorageVariant implements StringRepresentable, StorageVariant { + SIXTY_FOUR_B("64b", 64L), + TWO_HUNDRED_FIFTY_SIX_B("256b", 256L), + THOUSAND_TWENTY_FOUR_B("1024b", 1024L), + EIGHT_THOUSAND_NINETY_TWO_B("8192b", 8192L), + CREATIVE("creative", null); + + private final String name; + private final ResourceLocation storageDiskId; + @Nullable + private final ResourceLocation storagePartId; + @Nullable + private final Long capacityInBuckets; + + ChemicalStorageVariant(final String name, @Nullable final Long capacityInBuckets) { + this.name = name; + this.storagePartId = capacityInBuckets != null + ? createMekanismIntegrationIdentifier(name + "_chemical_storage_part") + : null; + this.storageDiskId = createMekanismIntegrationIdentifier(name + "_chemical_storage_disk"); + this.capacityInBuckets = capacityInBuckets; + } + + @Nullable + public Long getCapacityInBuckets() { + return capacityInBuckets; + } + + @Override + @Nullable + public Long getCapacity() { + if (capacityInBuckets == null) { + return null; + } + return capacityInBuckets * Platform.INSTANCE.getBucketAmount(); + } + + @Nullable + @Override + public Item getStoragePart() { + if (this == CREATIVE) { + return null; + } + return Items.INSTANCE.getChemicalStoragePart(this); + } + + public ResourceLocation getStorageDiskId() { + return storageDiskId; + } + + @Nullable + public ResourceLocation getStoragePartId() { + return storagePartId; + } + + @Override + public String getSerializedName() { + return name; + } +} diff --git a/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/package-info.java b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/package-info.java new file mode 100644 index 0000000..24b2a8b --- /dev/null +++ b/src/main/java/com/refinedmods/refinedstorage/mekanism/chemical/package-info.java @@ -0,0 +1,7 @@ +@ParametersAreNonnullByDefault +@FieldsAndMethodsAreNonnullByDefault +package com.refinedmods.refinedstorage.mekanism.chemical; + +import com.refinedmods.refinedstorage.api.core.FieldsAndMethodsAreNonnullByDefault; + +import javax.annotation.ParametersAreNonnullByDefault; diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/lang/en_us.json b/src/main/resources/assets/refinedstorage_mekanism_integration/lang/en_us.json index 7a73a41..59a357e 100644 --- a/src/main/resources/assets/refinedstorage_mekanism_integration/lang/en_us.json +++ b/src/main/resources/assets/refinedstorage_mekanism_integration/lang/en_us.json @@ -1,2 +1,16 @@ { + "misc.refinedstorage_mekanism_integration.resource_type.chemical": "Chemical", + "item.refinedstorage_mekanism_integration.64b_chemical_storage_part": "64B Chemical Storage Part", + "item.refinedstorage_mekanism_integration.256b_chemical_storage_part": "256B Chemical Storage Part", + "item.refinedstorage_mekanism_integration.1024b_chemical_storage_part": "1024B Chemical Storage Part", + "item.refinedstorage_mekanism_integration.8192b_chemical_storage_part": "8192B Chemical Storage Part", + "item.refinedstorage_mekanism_integration.64b_chemical_storage_disk": "64B Chemical Storage Disk", + "item.refinedstorage_mekanism_integration.256b_chemical_storage_disk": "256B Chemical Storage Disk", + "item.refinedstorage_mekanism_integration.1024b_chemical_storage_disk": "1024B Chemical Storage Disk", + "item.refinedstorage_mekanism_integration.8192b_chemical_storage_disk": "8192B Chemical Storage Disk", + "item.refinedstorage_mekanism_integration.creative_chemical_storage_disk": "Creative Chemical Storage Disk", + "item.refinedstorage_mekanism_integration.chemical_storage_disk.help": "Stores %s buckets.", + "item.refinedstorage_mekanism_integration.creative_chemical_storage_disk.help": "Stores an infinite amount of buckets.", + "advancements.refinedstorage_mekanism_integration.storing_chemicals": "Storing chemicals", + "advancements.refinedstorage_mekanism_integration.storing_chemicals.description": "Craft a Chemical Storage Disk and put it in your Disk Drive" } \ No newline at end of file diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/1024b_chemical_storage_disk.json b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/1024b_chemical_storage_disk.json new file mode 100644 index 0000000..0a14888 --- /dev/null +++ b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/1024b_chemical_storage_disk.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "refinedstorage_mekanism_integration:item/1024b_chemical_storage_disk" + } +} diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/1024b_chemical_storage_part.json b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/1024b_chemical_storage_part.json new file mode 100644 index 0000000..43c56fc --- /dev/null +++ b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/1024b_chemical_storage_part.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "refinedstorage_mekanism_integration:item/1024b_chemical_storage_part" + } +} diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/256b_chemical_storage_disk.json b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/256b_chemical_storage_disk.json new file mode 100644 index 0000000..33d936a --- /dev/null +++ b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/256b_chemical_storage_disk.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "refinedstorage_mekanism_integration:item/256b_chemical_storage_disk" + } +} diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/256b_chemical_storage_part.json b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/256b_chemical_storage_part.json new file mode 100644 index 0000000..81a5b1b --- /dev/null +++ b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/256b_chemical_storage_part.json @@ -0,0 +1 @@ +{ "parent": "item/generated", "textures": { "layer0": "refinedstorage_mekanism_integration:item/256b_chemical_storage_part" } } \ No newline at end of file diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/64b_chemical_storage_disk.json b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/64b_chemical_storage_disk.json new file mode 100644 index 0000000..798bc93 --- /dev/null +++ b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/64b_chemical_storage_disk.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "refinedstorage_mekanism_integration:item/64b_chemical_storage_disk" + } +} diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/64b_chemical_storage_part.json b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/64b_chemical_storage_part.json new file mode 100644 index 0000000..c4eced1 --- /dev/null +++ b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/64b_chemical_storage_part.json @@ -0,0 +1 @@ +{ "parent": "item/generated", "textures": { "layer0": "refinedstorage_mekanism_integration:item/64b_chemical_storage_part" } } \ No newline at end of file diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/8192b_chemical_storage_disk.json b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/8192b_chemical_storage_disk.json new file mode 100644 index 0000000..a76fdc8 --- /dev/null +++ b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/8192b_chemical_storage_disk.json @@ -0,0 +1 @@ +{ "parent": "item/generated", "textures": { "layer0": "refinedstorage_mekanism_integration:item/8192b_chemical_storage_disk" } } \ No newline at end of file diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/8192b_chemical_storage_part.json b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/8192b_chemical_storage_part.json new file mode 100644 index 0000000..400b2e7 --- /dev/null +++ b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/8192b_chemical_storage_part.json @@ -0,0 +1 @@ +{ "parent": "item/generated", "textures": { "layer0": "refinedstorage_mekanism_integration:item/8192b_chemical_storage_part" } } \ No newline at end of file diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/creative_chemical_storage_disk.json b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/creative_chemical_storage_disk.json new file mode 100644 index 0000000..d7c807d --- /dev/null +++ b/src/main/resources/assets/refinedstorage_mekanism_integration/models/item/creative_chemical_storage_disk.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "refinedstorage_mekanism_integration:item/creative_chemical_storage_disk" + } +} diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/textures/gui/sprites/chemical_resource_type.png b/src/main/resources/assets/refinedstorage_mekanism_integration/textures/gui/sprites/chemical_resource_type.png new file mode 100644 index 0000000000000000000000000000000000000000..32227a391db26bac332fe17933bd378e617c3eb4 GIT binary patch literal 407 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`jKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85sBugD~Uq{1qucL9r6oh?3y^w370~qEv=}#LT=BJwMkF1yeo4 z@6F#Q166EEjqptK^weVD0CHFvq!?Kl7=bJ=AeM%*L2l7tWCn{f0ojI(ObmQLItqw0 z+gZTk89+7&Bmgl;Ka57Pl7X3lVFEh?3sBy`$k>2!0mMv@de#LHb0z`VAixAPg$b-O z$kGDHg6c9fFaXIWFHt)Z=;uvD#pDc0bz^PNO>^YowMlcFbS!U<3O>(|= z#$%=&vqwd&Ut=52@4xY+qlnR$d7=h$pRDyUj#MFbk51M(YKyZKZi<#L@$fLrJ1KFY SSuQdbWP_)xpUXO@geCwMPE`c} literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/1024b_chemical_storage_disk.png b/src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/1024b_chemical_storage_disk.png new file mode 100644 index 0000000000000000000000000000000000000000..d7bf7d4dfa58fb72cce5b068848e7c320606dbc6 GIT binary patch literal 3147 zcmc&$32YQq7#^e{l|q2f2m-<|B3i=i+&eoHR@?)mz}B)XPzWGzXWq60yEDto^g?UE zizuR4Ny;TeBUOSNYD5YZEQnx4)Q|=Zhe!g5M8QB(f(pLr9)K;ji5NDSo$J58@BiLE z@1^3R$9r}k&>h3Do`vIrVRY{89J$@l|By@90Xp5A95>y6oI#z*z>%E&q;`vgo^Qi zVM1JTF{DD%EG|keH3~Qta3gV+W;u#sDTX6yL8jd@FX8DQfzp|3Ob!RfrjwyNFHvUO zNtvQ5D=S@ zQd#zx3RGemY$u$@R6yO%x~odoH(74RTWL}i3dUgqnOO)GldUsZX4r;RX55B^?CUHQ zNjYFbU>jz{Fyfgu7iXg2fdJ|%BjArr({$CSvpaOYBr8N1R%Ruc z6-e46({#!-WT;xKx~(ZE^Qk|f7sF;x{sBz1-t zNQUM`5^$nQ3JlLGz%2tBM>m%mhF((Gs8(Qc1m(z;9F%Fye-Zs6>2o&PqU$9R$$SDxf;nG!l5L zLS?NTPE?8KP}zV4Zj~cF67L~BK!PMx5ZjR9BvurNv_E1X%SopC7#HQ-Qj8{1m?$Yp zyhM6b)UmBun+ zb|o;OuM~-=?UG>ymw5AfNjWKHKre-8B2$C|)0tdtz$k`Z0Zsb`pd>H>8pP1FyhO}t za#kC-ZQvl8jB5&Th@dKTH9hOHnz?-*H6@!2?3=S>OTh17z7CtzS%o=GzS~Xe5KL#6 zTl--CF&6K-;yMtSqrH0T5STexZf8UP>>(@n( z&#HKTSWXjB|K+xGik#Qv?|r@3;XyOEpINr?p1Mere_Mlp$uh!Rn!9c1j1}adWwVO= zJmfx9^zzA5$2T|EG=J7|;sP^d)Z5GVOgPhg?k7*t+`@t>SnvHz^{#=h?Y}P69atW2 zp8N5)`X_yh>wl}28XI0XzhlM3;br`QenShe^^sqnxqR`=FWjL0i#DGx*);XN$cUA_ zuO1t8;@GLbrVKo7-oN_mZjG!JV;q>n> zw4eZM&o;Hx96W0^UMpF6^{Kj==RB`Y+BEgM3oTu+SC}4)16Ovf8^(Qc@nXrseMbisR~sSQ#4r8#EV{1B(?C#8a-(R2a`+UFey)O;)Z(H5At}T&BtnTf}4#NN1=(}3uR%}ong z8koN0g^pWcB8$XuN5eD=q1G{!z1VCeXygep##M>O2}wS}R1>t!Sk4>uOEu?~$<0gJjxByz#a8X znj3>KZ*HOq!a+Kh&n2jXc&r>c_5!-m%sf!E>MS4{&BUUfp7ALOUBBSEr6zd>nptEr z8Q_W_GaGg~70VqDHbyWSIy6f{nr2~MLA(k?DhR4Bq;wG@KBe<~T{Q1njy=&7#S#(( zgh5o)MG1sJb50bPY>|*GDr}j$?fPW`%ixqrk#b(8$TIQb>KV7>`rsI%6KhfA^LlS3 z2ua1Hz1cJi5R#5#>4v0e29FgaE0T;9B3Vc^6oPm$r4XzVQ82Woe%3WdBfdrY_1d#s z6Ku?RRYb*9OoEY?G9@G#l7KWmWgueMifL0#)+D8A?M~l;@+YNMt5H-|6qS}TY+kjI zU`rwrsKg`H)>MQInWT8jP;5(LnP|avFasfxsKnB&&=?$wh*uh|4{EY1YYHdu@M+BN zT4a81`r{P`QjA$9qD(!jJD`0*S`}Fq<;M7cQ>CS$tOMBz>VW{vnnrDA*Zdi1FLNnt z!taEI34nw_qxp1^V&kdgY-#32!&xk2HJ6b(u^{B6u1+=6)v0KT)Rh%--Es#Pbs12o zH?USsP0ET{RcLBzLYLO5WKx2h6S{L<+QOO!)?|zgj4UEsNWzkdh^WYj*wFs$lxWyC zZPBhpP!FEFI7$Eor0j7b)Dw+}chEg?>`blA=)|lqqZt(`wb;h6b0IP>i8gh!&?)GQRSDH%MVkW^$)h)|GB zECHD$o`))#kEgXc0v<7Lj!VLW*SJW7KbaR|&M^tUMKQbaaYO~pvY8bz`Ui$qjW zMy4Q(ilHeM=3)Q%|5&6&!6+$N9H~4Tb+jjPjzaGt-YeP-he%FbIJKOmWVu9`Z1>L&K?&3|yOx#GIz%V$>~TX+7! z-1e`%d*8rMo>;&C#Ns7d-nQ)^I|?(cswcjR}M?|y!&yRAAiJ-hC=&$rXj zXU`RXbJL&LD{lY6d)ZM^^J_MiTkU-jjaY~r<_7f+u;=kp_M|Ix|6S3bXQ z=E!TGymj^G)?Rb}J=2>DYu2=XD${p#^4Qx~zwpZs_laNq#T!p&q*EQw-MQxQ=2Pp> zy!(%XC#AQZVLrOSe*EC89ltuTV*eWJ#MY0D%p8C6k#6(*!L8zB_x7APHapw**w(K< W{pS^ToGwI{>fT&`_PbrXKl@LogEO@N literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/256b_chemical_storage_disk.png b/src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/256b_chemical_storage_disk.png new file mode 100644 index 0000000000000000000000000000000000000000..65eccd1f411c11bb3575224e64fe3756151526b2 GIT binary patch literal 3148 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 CMK@Of literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/64b_chemical_storage_part.png b/src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/64b_chemical_storage_part.png new file mode 100644 index 0000000000000000000000000000000000000000..419ffcaf4388e67973eab547bf1463b827779155 GIT binary patch literal 4001 zcmd5Q>hiV*K5St%p%Ta{a!W0|K;bS zJm=92zfLWQrCOd1c&kSOwsvGquQRgQF)4rhN^V8n0s$2k5w2b-S3|3w;Tv)-c#f9^ zo@<|0y1Bd`FwRU%$Pq=%>1LYRM5aVu&S4SDf`kQ0Mxttonx&Xr>%)V( zfVx&sVO2{Ryk+=-D5_b4Fg!e*9+uO7&@V`)X$m41Fh)Ru!Y$Q^)KN8D+?G&ap%Zwu z$n&dQERop$V3gs()TR%WS|YX@w&Da46Y8WUNNF+lsX<7cgswIilpD&aBd{{7uxbkm2mDDyC)*PgKx|8;M8^efsZAWxVh&z*!f-kIPOt9z4>#ybgV&B_OiM1Iig`{g!xy4z9Y@_E3D zq;gBwc~$BUhs$C&T0E>kB9`G{Uqhk+KL)7oD@#s2vA zJyj1vjCn4GOf#x$p?yJEHC2_>)_S*BXXUnH9&dl?T|+x;vgCIk?M zt>%*>{jI06x3V1<6Bn?GjbdKOVo540xvY`TWi?Y%as{clN?jquT?QDM4Xl&XR0?vz zklLK4lrythUYFFOw5pghC+D=WsbXwnM2Sj~g5#XZnu>@E?a$R^+jUt7cf*3F@xsNu z1g8L0tG(FkEiH@JvTr7~bB#7*5vQ3(CoWP(`PQ;`0WePwHchd^0}KFjk;-k7g}xgN zlYnLW0cF!^4#H&ihh*sD*2|)yD=MZ4D~gRoGcHAw+DMTlU84@Ov2M1#@3h`T5;POd z!XosOcHjA&*0+M|43KI+gOM!opWh#os!+2~#ExQ%;Dur!n}LOr;$Q{9q=+I^$;50- zXpW*KC(UtM{$Mq&clPNf({!A1{OS-3I^b0!0fA!$3&ITV27ZN0x-1v@9I4gHp3`VL z!cdjACU*k&$%95&;B~;DQ%hn3cM0`P2|Asqj$s-Ysn}#lRUt{lkX7VJs;t?jMzIL< z@MP{g^U=xu zKfZkC%O~y{J*^b>??H#7Q`gP>@LcfW*xnx%9_X?+?f>&A_vHNLyL#R^eDXx^(m8Xs zoiQ#u_36q3-?-!WrkD0zU4DPwuMUaFQU~|mdDW}OKAv~%#{0%*A9yLX>AB0D>-vvh z8_^#=Klka)S9sem+k20Y`omveIdk*YqV?2G`+o3oWq9Vct!JNDIRAs5xxYL2&}%&2 z_4<*=j-1`~>%qT0a}&S)t)1^~&piD8vaTgh{QkDjPM}>clMRc`UzwftmB-E)_WF5e zySHr}TJXh3Q`i6O+e_AM{p64Tc;tlp_}4!=|6JZeXq}WWW%#~?422>9<*Mp%{lqz;w7_h7&x%|?R!Ulk^bc;caK(= vZi_}fI=6Gh_a8jEbHShPK7W4C%GAaee>#8k^s}eqOLSLpP2u_6#{2&TLl!d! literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/8192b_chemical_storage_disk.png b/src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/8192b_chemical_storage_disk.png new file mode 100644 index 0000000000000000000000000000000000000000..bc2e709592ab8cc92e34d280fa5fab9e51844f7c GIT binary patch literal 3149 zcmc&$3vAS6952XYyv!zOCWBB41km;Ryz8~$fbBM9z|CdcWQqa4w%=`qySB95Z3ChR z!UP`-LF6f5GC*Rc1R;?LsED8#Bq0QmARz?M5JZD!MoH$^-CY3zSt5o@dVT$0zu*7& z{rfE`D}Aa@&;C6z4C_-ezNj3Xv)v=B8~Pt~tqq`44|DvpHiq@;>mHr3wd->+tY=V* zRyviDNs?kDd_Xm1=&MVZ$Qr{&jj1z%G7CDm468IfL|kpzPvDvwBBuBwbi@q9YHj=+ z3r?O>8dc`ZQbd&)Ga4UNC!qid=m5Mf5!Y?0E=07)mC&{Om?H3Y6K7V4C~yZ$OPn7|u0xlnCX_liHmSQ-P_Dgg?;zd0DBTza^jY;K25{U5Kc5 z98;pG+S*!QE$1_=DvA+Bk)m0OWl3Z~+V#2v>PX!ll8I0RZN<_|M>BNXjR<6;#t9Lq z)D(t<>4nwpG*5^zst%YG1n~*Apwozj#5Sb6j zq_UmjBq}itwgb+^NvJ!XyQ+A;W{nkZr%6>P7>5aDW+POLSEpHRIEGzq+=T@1wMT_1 zg)Imi!-^V4Jk#c~OcXpEMqOq6_=qW*t{S!WNEcJu2NnSbh6vPko@5x3^+y?2VnvDd zlXOs`>6B^2P_vl1uXVv01U0ta-&I1-UcblU;C0!xZQ1S-m>X{scs3L~h& z04WQiOa>UQ<$qh+>d05DG=cALjfFQydTlzgQs9 z;R2yx94CYe30zgAm|-OVl8Kf8Rgg0EDgwVzN!W-R7NQdI&ABT9MRpNDOG`p^oMj~N zc7;mX9XJW9Pyq@IkdO|FBv11)LLs9yO0$5Ic}9)J1S0K^81OjBR3GDHE+8V@tTb!S)U#nli}?2Ra`@LqQxWu#T@`4!UhPx zTfF=5PT*-Sz^SUtl8hj*r0nOBG+YEK7YlF!UhwY3*xE|3vvDvfQ# zoLXSPf+{4Q+m{UM_X#(zmz0xI4fHCACNf31Fx|;@8yLmVlhAT*05X9E&>)7E9U@|G zlRa(Vj)4QyjB5&TiJ+3Ynx1u@X6~LxP01z$`{pcO3HW`?ch4quRAFwDA9R!M38tgV z?apBSF%}=V;_e|bSBIV`?}y^CJ1e|OXF z2ThUoM`%msUV583bmMIYp^hewg*JQH$rp7D>(o+GR1gim-n3$e@%`A`gJ(Ci%%ykN z#0m#C=1v&imeZ71UiNrn_Qc)2*Bn{f%$IL*AU=)F-Br=BDL-pT)51Ov{rYK1*2MYQ z+w#{_;YGzVcVS)WpFjK+Ix{>(G<`Ak;+b>cbW$!E`4*O4oKwFyuXndL|JK7R%THDF z$KnB{Z2QkEPlZ|*o)6|e+_3G$%;AH3U`^4{^V$|sWAZ*s??Ia>qe`wt@*ft%KrKS`~1nS*tYFUr+v`V?@vj~TD! z9GYGBUi8?NWKNe(tBwp?fWNZh(%tzn3H0;ej2gU~0 z4O@Thw>*_wlK?iE?ObvkMzP x+BXzy$SKVJa`h*B&V(l{A8{NUo_hIu@6nA1`|aEjeB0gdmlT&4H5blU@HZ@xDT@FA literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/8192b_chemical_storage_part.png b/src/main/resources/assets/refinedstorage_mekanism_integration/textures/item/8192b_chemical_storage_part.png new file mode 100644 index 0000000000000000000000000000000000000000..02624fefe990f9f1a6228dce2e38c89b3f8c67b7 GIT binary patch literal 4145 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 literal 0 HcmV?d00001 diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/advancement/storing_chemicals.json b/src/main/resources/data/refinedstorage_mekanism_integration/advancement/storing_chemicals.json new file mode 100644 index 0000000..31f54f5 --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/advancement/storing_chemicals.json @@ -0,0 +1,26 @@ +{ + "display": { + "icon": { + "id": "refinedstorage_mekanism_integration:64b_chemical_storage_disk" + }, + "title": { + "translate": "advancements.refinedstorage_mekanism_integration.storing_chemicals" + }, + "description": { + "translate": "advancements.refinedstorage_mekanism_integration.storing_chemicals.description" + } + }, + "parent": "refinedstorage:drives", + "criteria": { + "chemical_storage_disk_in_inventory": { + "trigger": "minecraft:inventory_changed", + "conditions": { + "items": [ + { + "items": "#refinedstorage_mekanism_integration:chemical_storage_disks" + } + ] + } + } + } +} diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_disk.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_disk.json new file mode 100644 index 0000000..3969052 --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_disk.json @@ -0,0 +1,25 @@ +{ + "type": "minecraft:crafting_shaped", + "pattern": [ + "GRG", + "RPR", + "EEE" + ], + "key": { + "G": { + "tag": "c:glass_blocks" + }, + "R": { + "tag": "c:dusts/redstone" + }, + "P": { + "item": "refinedstorage_mekanism_integration:1024b_chemical_storage_part" + }, + "E": { + "item": "mekanism:ingot_osmium" + } + }, + "result": { + "id": "refinedstorage_mekanism_integration:1024b_chemical_storage_disk" + } +} diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_disk_from_storage_housing.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_disk_from_storage_housing.json new file mode 100644 index 0000000..d6cde0a --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_disk_from_storage_housing.json @@ -0,0 +1,14 @@ +{ + "type": "minecraft:crafting_shapeless", + "ingredients": [ + { + "item": "refinedstorage:storage_housing" + }, + { + "item": "refinedstorage_mekanism_integration:1024b_chemical_storage_part" + } + ], + "result": { + "id": "refinedstorage_mekanism_integration:1024b_chemical_storage_disk" + } +} diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_disk_upgrade.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_disk_upgrade.json new file mode 100644 index 0000000..a7bc851 --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_disk_upgrade.json @@ -0,0 +1,4 @@ +{ + "type": "refinedstorage_mekanism_integration:chemical_storage_disk_upgrade", + "to": "1024b" +} \ No newline at end of file diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_part.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_part.json new file mode 100644 index 0000000..a103fa8 --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/1024b_chemical_storage_part.json @@ -0,0 +1,25 @@ +{ + "type": "minecraft:crafting_shaped", + "pattern": [ + "PEP", + "SRS", + "PSP" + ], + "key": { + "P": { + "item": "refinedstorage:improved_processor" + }, + "E": { + "item": "mekanism:ingot_osmium" + }, + "S": { + "item": "refinedstorage_mekanism_integration:256b_chemical_storage_part" + }, + "R": { + "item": "mekanism:alloy_reinforced" + } + }, + "result": { + "id": "refinedstorage_mekanism_integration:1024b_chemical_storage_part" + } +} diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_disk.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_disk.json new file mode 100644 index 0000000..bf214f9 --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_disk.json @@ -0,0 +1,25 @@ +{ + "type": "minecraft:crafting_shaped", + "pattern": [ + "GRG", + "RPR", + "EEE" + ], + "key": { + "G": { + "tag": "c:glass_blocks" + }, + "R": { + "tag": "c:dusts/redstone" + }, + "P": { + "item": "refinedstorage_mekanism_integration:256b_chemical_storage_part" + }, + "E": { + "item": "mekanism:ingot_osmium" + } + }, + "result": { + "id": "refinedstorage_mekanism_integration:256b_chemical_storage_disk" + } +} diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_disk_from_storage_housing.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_disk_from_storage_housing.json new file mode 100644 index 0000000..44e6e04 --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_disk_from_storage_housing.json @@ -0,0 +1,14 @@ +{ + "type": "minecraft:crafting_shapeless", + "ingredients": [ + { + "item": "refinedstorage:storage_housing" + }, + { + "item": "refinedstorage_mekanism_integration:256b_chemical_storage_part" + } + ], + "result": { + "id": "refinedstorage_mekanism_integration:256b_chemical_storage_disk" + } +} diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_disk_upgrade.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_disk_upgrade.json new file mode 100644 index 0000000..2319b71 --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_disk_upgrade.json @@ -0,0 +1,4 @@ +{ + "type": "refinedstorage_mekanism_integration:chemical_storage_disk_upgrade", + "to": "256b" +} \ No newline at end of file diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_part.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_part.json new file mode 100644 index 0000000..f71d05a --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/256b_chemical_storage_part.json @@ -0,0 +1,25 @@ +{ + "type": "minecraft:crafting_shaped", + "pattern": [ + "PEP", + "SRS", + "PSP" + ], + "key": { + "P": { + "item": "refinedstorage:basic_processor" + }, + "E": { + "item": "mekanism:ingot_osmium" + }, + "S": { + "item": "refinedstorage_mekanism_integration:64b_chemical_storage_part" + }, + "R": { + "item": "mekanism:alloy_infused" + } + }, + "result": { + "id": "refinedstorage_mekanism_integration:256b_chemical_storage_part" + } +} diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/64b_chemical_storage_disk.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/64b_chemical_storage_disk.json new file mode 100644 index 0000000..15e60f1 --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/64b_chemical_storage_disk.json @@ -0,0 +1,25 @@ +{ + "type": "minecraft:crafting_shaped", + "pattern": [ + "GRG", + "RPR", + "EEE" + ], + "key": { + "G": { + "tag": "c:glass_blocks" + }, + "R": { + "tag": "c:dusts/redstone" + }, + "P": { + "item": "refinedstorage_mekanism_integration:64b_chemical_storage_part" + }, + "E": { + "item": "mekanism:ingot_osmium" + } + }, + "result": { + "id": "refinedstorage_mekanism_integration:64b_chemical_storage_disk" + } +} diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/64b_chemical_storage_disk_from_storage_housing.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/64b_chemical_storage_disk_from_storage_housing.json new file mode 100644 index 0000000..f32cc35 --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/64b_chemical_storage_disk_from_storage_housing.json @@ -0,0 +1,14 @@ +{ + "type": "minecraft:crafting_shapeless", + "ingredients": [ + { + "item": "refinedstorage:storage_housing" + }, + { + "item": "refinedstorage_mekanism_integration:64b_chemical_storage_part" + } + ], + "result": { + "id": "refinedstorage_mekanism_integration:64b_chemical_storage_disk" + } +} diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/64b_chemical_storage_part.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/64b_chemical_storage_part.json new file mode 100644 index 0000000..669ae13 --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/64b_chemical_storage_part.json @@ -0,0 +1,25 @@ +{ + "type": "minecraft:crafting_shaped", + "pattern": [ + "SES", + "GRG", + "SGS" + ], + "key": { + "S": { + "tag": "c:silicon" + }, + "E": { + "item": "mekanism:ingot_osmium" + }, + "G": { + "tag": "c:glass_blocks" + }, + "R": { + "tag": "c:dusts/redstone" + } + }, + "result": { + "id": "refinedstorage_mekanism_integration:64b_chemical_storage_part" + } +} diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_disk.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_disk.json new file mode 100644 index 0000000..17d57ac --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_disk.json @@ -0,0 +1,25 @@ +{ + "type": "minecraft:crafting_shaped", + "pattern": [ + "GRG", + "RPR", + "EEE" + ], + "key": { + "G": { + "tag": "c:glass_blocks" + }, + "R": { + "tag": "c:dusts/redstone" + }, + "P": { + "item": "refinedstorage_mekanism_integration:8192b_chemical_storage_part" + }, + "E": { + "item": "mekanism:ingot_osmium" + } + }, + "result": { + "id": "refinedstorage_mekanism_integration:8192b_chemical_storage_disk" + } +} diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_disk_from_storage_housing.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_disk_from_storage_housing.json new file mode 100644 index 0000000..3665faa --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_disk_from_storage_housing.json @@ -0,0 +1,14 @@ +{ + "type": "minecraft:crafting_shapeless", + "ingredients": [ + { + "item": "refinedstorage:storage_housing" + }, + { + "item": "refinedstorage_mekanism_integration:8192b_chemical_storage_part" + } + ], + "result": { + "id": "refinedstorage_mekanism_integration:8192b_chemical_storage_disk" + } +} diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_disk_upgrade.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_disk_upgrade.json new file mode 100644 index 0000000..6d879f5 --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_disk_upgrade.json @@ -0,0 +1,4 @@ +{ + "type": "refinedstorage_mekanism_integration:chemical_storage_disk_upgrade", + "to": "8192b" +} \ No newline at end of file diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_part.json b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_part.json new file mode 100644 index 0000000..a684a40 --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/recipe/8192b_chemical_storage_part.json @@ -0,0 +1,25 @@ +{ + "type": "minecraft:crafting_shaped", + "pattern": [ + "PEP", + "SRS", + "PSP" + ], + "key": { + "P": { + "item": "refinedstorage:advanced_processor" + }, + "E": { + "item": "mekanism:ingot_osmium" + }, + "S": { + "item": "refinedstorage_mekanism_integration:1024b_chemical_storage_part" + }, + "R": { + "item": "mekanism:alloy_atomic" + } + }, + "result": { + "id": "refinedstorage_mekanism_integration:8192b_chemical_storage_part" + } +} diff --git a/src/main/resources/data/refinedstorage_mekanism_integration/tags/item/chemical_storage_disks.json b/src/main/resources/data/refinedstorage_mekanism_integration/tags/item/chemical_storage_disks.json new file mode 100644 index 0000000..d737c9f --- /dev/null +++ b/src/main/resources/data/refinedstorage_mekanism_integration/tags/item/chemical_storage_disks.json @@ -0,0 +1,9 @@ +{ + "replace": false, + "values": [ + "refinedstorage_mekanism_integration:64b_chemical_storage_disk", + "refinedstorage_mekanism_integration:256b_chemical_storage_disk", + "refinedstorage_mekanism_integration:1024b_chemical_storage_disk", + "refinedstorage_mekanism_integration:8192b_chemical_storage_disk" + ] +}