diff --git a/CHANGELOG.md b/CHANGELOG.md index 10e875e..e12f5f1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,11 @@ +# v1.3.0 +## New: Storage Drawers Integration +- GT materials can now be used to craft _Storage Upgrades_. +- Craftable materials, multipliers, and related settings can be configured via cfg. +- Original materials (Obsidian/Iron/Gold/Diamond/Emerald) are always included. + +* * * + # v1.2.4 ## Tinkers' Construct Integration - Fixed GT main-hand + TiC off-hand combination dropping items twice diff --git a/DEVELOPER.md b/DEVELOPER.md index 7333cc5..e1bfa91 100644 --- a/DEVELOPER.md +++ b/DEVELOPER.md @@ -3,11 +3,12 @@ GTMoreTools exposes addon APIs for its mod integrations. The table below shows current coverage: -| Integration | API package | Status | -|---|---|---| -| Tinkers' Construct | `integration.tic.api` | Available | -| Better Builder's Wands | — | No API yet | -| Chisel | — | No API yet | +| Integration | API package | Status | +|------------------------|----------------------------------|-------------------------------| +| Tinkers' Construct | `integration.tic.api` | Available | +| Better Builder's Wands | — | No API yet | +| Chisel | — | No API yet | +| Storage Drawers | `integration.storagedrawers.api` | Available, but for mixin only | All registration calls must happen during your mod's `preInit` phase, **before** GTMT's `registerBlocks`, unless stated otherwise. @@ -160,3 +161,73 @@ Parallel count scales as `4^(tier − EV) / 2` from EV upward. ### Bookshelf variants (Assembler) 6 wood types × 1 recipe each: 6 planks + 3 Books → carved Bookshelf (100 EU, ULV). + +--- + +## Storage Drawers Integration +An addon API currently exists, but it is mixin-based and not usable. The following describes the internal logic for reference. + +### What is added + +- Storage Upgrades made from GT materials will be registered for the GT materials specified in the cfg. + +### Config Options + +`removeOriginal` +- Controls whether the default Storage Upgrade recipes are removed. + - true: All original Storage Upgrade recipes are removed. Only recipes defined by this mod (via upgradeMaterials) will be available. + - false: Original recipes remain alongside the newly added ones. +- Use this if you want to fully replace the default progression with GT-based materials. + +`upgradeMaterials` +- Defines custom materials used to craft Storage Upgrades. +- Each entry adds a new Storage Upgrade variant based on a GT material. + +#### _Format_ +`modId:materialName@multiplier%tier` + +#### _Parameters_ +- `materialName`: Must be a valid GT material with a dust property. +- `multiplier`: Determines the storage capacity multiplier of the upgrade. + - Range: 1 to 2147483647 + - Not affected by the StorageDrawers config. +- `tier` (optional): Required Field Generator tier. + - Range: 1 (LV) to 8 (UV) + - If omitted, defaults to -1 (no Field Generator required). + +#### _Behavior_ +- A Storage Upgrade using the specified material will be registered for each entry. +- If the config is empty, only the original materials are available. +- Original materials (Obsidian / Iron / Gold / Diamond / Emerald): + - Always included automatically. + - Use tier -1. + - Their multipliers are controlled by the StorageDrawers config. + - **Do NOT define them here.** + +#### _Example_ +`gregtech:steel@4%2` +- Adds a Steel Storage Upgrade + - Multiplier: x4 + - Requires MV-tier Field Generator + +#### _Logging_ +- Registration results can be checked in the log. +- The process starts with `[GT More Tools]: UpgradeMaterialData registration started.` and ends with `[GT More Tools]: UpgradeMaterialData registration finished.` +- On successful registration, the following message is logged: `[GT More Tools]: Registered UpgradeMaterial (Material=..., meta=..., multiplier=x..., requiredTier=...)` + - For example, a successful registration will produce a log like: `[GT More Tools]: Registered UpgradeMaterial (Material=steel, meta=324, multiplier=x4, requiredTier=2 (MV))` +- Entries with an invalid format will be skipped, and the log will indicate the issue. + +### Crafting + +``` +P S P +S U S +P X P +``` + +- **P** = `plate` +- **S** = `screw` +- **U** = Upgrade Template +- **X** = If _tier_ is -1, a `stickLong`; otherwise, a `Field Generator` of the specified tier + +- _Storage Upgrade_ conversion recipes between StorageDrawers and GTMoreTools are always added for Obsidian / Iron / Gold / Diamond / Emerald. diff --git a/README.md b/README.md index 37cef33..c1e413e 100644 --- a/README.md +++ b/README.md @@ -29,6 +29,9 @@ This mod is an add-on for GregTech CEu that provides integration with various mo For full details, see [CHANGELOG.md](CHANGELOG.md). +### Storage Drawers Integration +- Add GT material-based Storage Upgrades. + ## For Addon Developers GTMoreTools exposes a public API for extending the Tinkers' Construct integration. diff --git a/buildscript.properties b/buildscript.properties index 359c7f6..e344628 100644 --- a/buildscript.properties +++ b/buildscript.properties @@ -34,6 +34,7 @@ debug_all = false debug_chisel = false debug_bbw = false debug_tic = false +debug_drawers = false # Select a username for testing your mod with breakpoints. You may leave this empty for a random username each time you # restart Minecraft in development. Choose this dependent on your mod: diff --git a/dependencies.gradle b/dependencies.gradle index 5b3069b..bb542e5 100644 --- a/dependencies.gradle +++ b/dependencies.gradle @@ -68,4 +68,13 @@ dependencies { runtimeOnly rfg.deobf("curse.maven:mantle-74924:2713386") runtimeOnly rfg.deobf("curse.maven:tinkers-antique-1242239:7339332") } + + // Debug Storage Drawers: 1.12-5.5.3 + compileOnly rfg.deobf("curse.maven:chameleon-230497:2450900") // Chameleon-1.12-4.1.3 + compileOnly rfg.deobf("curse.maven:storage-drawers-223852:5981297") + if (project.debug_all.toBoolean() || project.debug_drawers.toBoolean()) { + runtimeOnly rfg.deobf("curse.maven:chameleon-230497:2450900") // Chameleon-1.12-4.1.3 + runtimeOnly rfg.deobf("curse.maven:storage-drawers-223852:5981297") + implementation rfg.deobf("curse.maven:topalldependents-1120632:6138503") + } } diff --git a/src/main/java/com/github/gtexpert/gtmt/api/unification/material/info/GTMTMaterialFlags.java b/src/main/java/com/github/gtexpert/gtmt/api/unification/material/info/GTMTMaterialFlags.java new file mode 100644 index 0000000..656b3da --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/api/unification/material/info/GTMTMaterialFlags.java @@ -0,0 +1,61 @@ +package com.github.gtexpert.gtmt.api.unification.material.info; + +import java.util.HashSet; +import java.util.Set; + +import gregtech.api.GregTechAPI; +import gregtech.api.unification.material.Material; +import gregtech.api.unification.material.Materials; +import gregtech.api.unification.material.info.MaterialFlags; +import gregtech.api.unification.material.properties.PropertyKey; + +import com.github.gtexpert.gtmt.api.util.ModLog; +import com.github.gtexpert.gtmt.integration.storagedrawers.StorageDrawersConfigHolder; + +public class GTMTMaterialFlags { + + public static void integrationStorageDrawers() { + Set materials = new HashSet<>(); + materials.add(Materials.Obsidian); + materials.add(Materials.Iron); + materials.add(Materials.Gold); + materials.add(Materials.Diamond); + materials.add(Materials.Emerald); + + for (String str : StorageDrawersConfigHolder.upgradeMaterials) { + if (str.isEmpty()) continue; + + String[] split1 = str.split("@", 2); + + if (split1.length != 2) { + continue; + + } + String materialPart = split1[0]; + + if (!materialPart.contains(":")) { + continue; + } + + Material material = GregTechAPI.materialManager.getMaterial(materialPart); + + if (material == null) { + continue; + } + + if (!material.hasProperty(PropertyKey.DUST)) { + ModLog.logger.warn("Material must have dust property. Skipping entry."); + continue; + } + materials.add(material); + } + + for (Material material : materials) { + if (!material.hasFlag(MaterialFlags.GENERATE_PLATE)) material.addFlags(MaterialFlags.GENERATE_PLATE); + if (!material.hasFlag(MaterialFlags.GENERATE_ROD)) material.addFlags(MaterialFlags.GENERATE_ROD); + if (!material.hasFlag(MaterialFlags.GENERATE_LONG_ROD)) material.addFlags(MaterialFlags.GENERATE_LONG_ROD); + if (!material.hasFlag(MaterialFlags.GENERATE_BOLT_SCREW)) + material.addFlags(MaterialFlags.GENERATE_BOLT_SCREW); + } + } +} diff --git a/src/main/java/com/github/gtexpert/gtmt/api/util/Mods.java b/src/main/java/com/github/gtexpert/gtmt/api/util/Mods.java index bbf06bc..a22c9d1 100644 --- a/src/main/java/com/github/gtexpert/gtmt/api/util/Mods.java +++ b/src/main/java/com/github/gtexpert/gtmt/api/util/Mods.java @@ -68,6 +68,7 @@ public enum Mods { ProjectRedIllumination(Names.PROJECT_RED_ILLUMINATION), Railcraft(Names.RAILCRAFT), RefinedStorage(Names.REFINED_STORAGE), + StorageDrawers(Names.STORAGE_DRAWERS), Thaumcraft(Names.THAUMCRAFT), ThaumicEnergistics(Names.THAUMIC_ENERGISTICS), TheOneProbe(Names.THE_ONE_PROBE), @@ -143,6 +144,7 @@ public static class Names { public static final String PROJECT_RED_ILLUMINATION = "projectred-illumination"; public static final String RAILCRAFT = "railcraft"; public static final String REFINED_STORAGE = "refinedstorage"; + public static final String STORAGE_DRAWERS = "storagedrawers"; public static final String THAUMCRAFT = "thaumcraft"; public static final String THAUMIC_ENERGISTICS = "thaumicenergistics"; public static final String THE_ONE_PROBE = "theoneprobe"; diff --git a/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/StorageDrawersConfigHolder.java b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/StorageDrawersConfigHolder.java new file mode 100644 index 0000000..1df9a40 --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/StorageDrawersConfigHolder.java @@ -0,0 +1,44 @@ +package com.github.gtexpert.gtmt.integration.storagedrawers; + +import net.minecraftforge.common.config.Config; + +import com.github.gtexpert.gtmt.api.ModValues; +import com.github.gtexpert.gtmt.modules.Modules; + +@Config.LangKey(ModValues.MODID + ".config.integration.storage_drawers") +@Config(modid = ModValues.MODID, + name = ModValues.MODID + "/integration/" + Modules.MODULE_DRAWERS, + category = "StorageDrawers") +public class StorageDrawersConfigHolder { + + @Config.Comment({ "Remove original storage upgrade recipe", "default: true" }) + public static boolean removeOriginal = true; + + @Config.Comment({ "Specifies the materials that can be used to craft Storage Upgrades.", + "Format: modId:materialName@multiplier%tier", + "==Notes==", + "--Material--", + "Must have the dust property", + "--Multiplier--", + "The range of \"multiplier\" is 1 to 2147483647", + "The \"multiplier\" value is not affected by StorageDrawers config.", + "--Tier--", + "\"tier\" represents the required field generator tier and can be set from 1 (LV) to 8 (UV).", + "The \"tier\" field is optional and defaults to -1 (no field generator required) if omitted.", + "--Others--", + "Original materials (Obsidian/Iron/Gold/Diamond/Emerald) are automatically added with tier -1.", + "Do not specify them here.", + "The multiplier values for original materials are controlled by the StorageDrawers config.", + "If this entry is left empty, only the original materials will be added." }) + public static String[] upgradeMaterials = new String[] { + "gregtech:wrought_iron@4", "gregtech:bronze@8", + "gregtech:steel@16", "gregtech:bismuth_bronze@32%1", + "gregtech:aluminium@64", "gregtech:rose_gold@128%2", + "gregtech:stainless_steel@256", "gregtech:ultimet@512%3", + "gregtech:titanium@1024", "gregtech:ruridit@2048%4", + "gregtech:tungsten_steel@4096", "gregtech:hssg@8192%5", + "gregtech:rhodium_plated_palladium@16384", "gregtech:europium@32768%6", + "gregtech:naquadah_alloy@65536", "gregtech:americium@131072%7", + "gregtech:darmstadtium@262144", "gregtech:neutronium@524288%8" + }; +} diff --git a/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/StorageDrawersModule.java b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/StorageDrawersModule.java new file mode 100644 index 0000000..395b39b --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/StorageDrawersModule.java @@ -0,0 +1,99 @@ +package com.github.gtexpert.gtmt.integration.storagedrawers; + +import static com.github.gtexpert.gtmt.integration.storagedrawers.items.StorageDrawersItems.upgradeStorageGT; + +import java.util.Collections; +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.crafting.IRecipe; +import net.minecraftforge.client.event.ModelRegistryEvent; +import net.minecraftforge.event.RegistryEvent; +import net.minecraftforge.fml.common.event.FMLInitializationEvent; +import net.minecraftforge.fml.common.event.FMLPostInitializationEvent; +import net.minecraftforge.fml.common.event.FMLPreInitializationEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; +import net.minecraftforge.registries.IForgeRegistry; + +import org.jetbrains.annotations.NotNull; + +import gregtech.api.unification.material.event.PostMaterialEvent; + +import com.github.gtexpert.gtmt.api.ModValues; +import com.github.gtexpert.gtmt.api.modules.TModule; +import com.github.gtexpert.gtmt.api.unification.material.info.GTMTMaterialFlags; +import com.github.gtexpert.gtmt.api.util.Mods; +import com.github.gtexpert.gtmt.integration.IntegrationSubmodule; +import com.github.gtexpert.gtmt.integration.storagedrawers.items.ItemGTMaterialUpgradeStorage; +import com.github.gtexpert.gtmt.integration.storagedrawers.items.StorageDrawersItems; +import com.github.gtexpert.gtmt.integration.storagedrawers.recipes.UpgradesLoader; +import com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades.StorageUpgradeColors; +import com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades.UpgradeMaterialData; +import com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades.UpgradesMaterialRegistry; +import com.github.gtexpert.gtmt.modules.Modules; + +@TModule( + moduleID = Modules.MODULE_DRAWERS, + containerID = ModValues.MODID, + modDependencies = Mods.Names.STORAGE_DRAWERS, + name = "GTMoreTools Storage Drawers Integration", + description = "Storage Drawers Module") +public class StorageDrawersModule extends IntegrationSubmodule { + + @NotNull + @Override + public List> getEventBusSubscribers() { + return Collections.singletonList(StorageDrawersModule.class); + } + + @Override + public void preInit(FMLPreInitializationEvent event) { + StorageDrawersItems.init(); + } + + @Override + @SideOnly(Side.CLIENT) + public void init(FMLInitializationEvent event) { + StorageUpgradeColors.init(); + } + + @Override + public void postInit(FMLPostInitializationEvent event) {} + + @SubscribeEvent + public static void onRegisterItems(RegistryEvent.Register event) { + IForgeRegistry registry = event.getRegistry(); + registry.register(upgradeStorageGT); + } + + @SubscribeEvent + @SideOnly(Side.CLIENT) + public static void onRegisterModels(ModelRegistryEvent event) { + ItemGTMaterialUpgradeStorage.registerModels(); + } + + @SubscribeEvent + public static void registerMaterialFlags(PostMaterialEvent event) { + GTMTMaterialFlags.integrationStorageDrawers(); + } + + @Override + public void registerBlocks(RegistryEvent.Register event) {} + + @Override + public void registerRecipesNormal(RegistryEvent.Register event) { + StorageDrawersUtil.UPGRADE_MATERIALS = StorageDrawersUtil.parse(StorageDrawersConfigHolder.upgradeMaterials); + for (UpgradeMaterialData data : StorageDrawersUtil.UPGRADE_MATERIALS) { + UpgradesMaterialRegistry.REGISTRY.put(data.getMaterial(), data.getId(), data.getMultiple(), + data.getTier()); + } + } + + @Override + public void registerRecipesLowest(RegistryEvent.Register event) { + UpgradesLoader.upgradeStorage(); + } +} diff --git a/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/StorageDrawersUtil.java b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/StorageDrawersUtil.java new file mode 100644 index 0000000..138bf1b --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/StorageDrawersUtil.java @@ -0,0 +1,129 @@ +package com.github.gtexpert.gtmt.integration.storagedrawers; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import net.minecraft.util.math.MathHelper; + +import com.jaquadro.minecraft.storagedrawers.StorageDrawers; +import com.jaquadro.minecraft.storagedrawers.config.ConfigManager; +import com.jaquadro.minecraft.storagedrawers.item.EnumUpgradeStorage; + +import gregtech.api.GTValues; +import gregtech.api.GregTechAPI; +import gregtech.api.unification.material.Material; +import gregtech.api.unification.material.properties.PropertyKey; + +import com.github.gtexpert.gtmt.api.util.ModLog; +import com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades.UpgradeMaterialData; + +public class StorageDrawersUtil { + + private static final ConfigManager config = StorageDrawers.config; + + public static List UPGRADE_MATERIALS = new ArrayList<>(); + + public static List parse(String[] entries) { + Map check = new HashMap<>(); + List result = new ArrayList<>(); + + ModLog.logger.info("UpgradeMaterialData registration started."); + + String[] defaultEntries = new String[] { + "gregtech:obsidian@" + config.getStorageUpgradeMultiplier(EnumUpgradeStorage.OBSIDIAN.getLevel()), + "gregtech:iron@" + config.getStorageUpgradeMultiplier(EnumUpgradeStorage.IRON.getLevel()), + "gregtech:gold@" + config.getStorageUpgradeMultiplier(EnumUpgradeStorage.GOLD.getLevel()), + "gregtech:diamond@" + config.getStorageUpgradeMultiplier(EnumUpgradeStorage.DIAMOND.getLevel()), + "gregtech:emerald@" + config.getStorageUpgradeMultiplier(EnumUpgradeStorage.EMERALD.getLevel()) + }; + + String[] newEntries = prepend(entries, defaultEntries); + + for (String entry : newEntries) { + String[] split1 = entry.split("@", 2); + if (split1.length != 2) { + ModLog.logger.warn("Missing '@': {}, Skipping entry.", entry); + continue; + } + + String materialPart = split1[0]; + String otherPart = split1[1]; + + if (!materialPart.contains(":")) { + ModLog.logger.warn("Invalid material format (missing ':'): {}. Skipping entry.", entry); + continue; + } + + Material material = GregTechAPI.materialManager.getMaterial(materialPart); + + if (material == null) { + ModLog.logger.warn("Cannot find '{}'. Skipping entry", materialPart); + continue; + } + + if (!material.hasProperty(PropertyKey.DUST)) { + ModLog.logger.warn("Material must have dust property. Skipping entry."); + continue; + } + + int id = material.getId(); + + String[] percentSplit = otherPart.split("%", 2); + + int multiplier; + try { + multiplier = Integer.parseInt(percentSplit[0]); + } catch (NumberFormatException e) { + ModLog.logger.warn("Invalid multiplier: {}. Skipping entry.", entry, e); + continue; + } + + int tier = -1; + int value; + if (percentSplit.length == 2 && !percentSplit[1].isEmpty()) { + try { + value = Integer.parseInt(percentSplit[1]); + } catch (NumberFormatException e) { + ModLog.logger.warn("Invalid tier: {}. Skipping entry.", entry, e); + continue; + } + + if (value < 1 || 8 < value) { + tier = MathHelper.clamp(value, 1, 8); + ModLog.logger.warn("Tier is out of range. Fallback to {}", tier); + } else + tier = value; + } + if (check.containsKey(id)) { + ModLog.logger.warn("Duplicate id: {}. Skipping entry.", id); + continue; + } + + UpgradeMaterialData data = new UpgradeMaterialData(material, id, multiplier, tier); + check.put(id, data); + result.add(data); + if (tier == -1) { + ModLog.logger.info( + "Registered UpgradeMaterial (Material={}, meta={}, multiplier=x{})", + material, id, multiplier); + } else { + ModLog.logger.info( + "Registered UpgradeMaterial (Material={}, meta={}, multiplier=x{}, requiredTier={} ({}))", + material, id, multiplier, tier, GTValues.VN[tier]); + + } + } + ModLog.logger.info("UpgradeMaterialData registration finished."); + return result; + } + + private static String[] prepend(String[] args1, String[] args2) { + String[] result = new String[args2.length + args1.length]; + System.arraycopy(args2, 0, result, 0, args2.length); + System.arraycopy(args1, 0, result, args2.length, args1.length); + + return result; + } +} diff --git a/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/api/IStorageMultiplier.java b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/api/IStorageMultiplier.java new file mode 100644 index 0000000..bac1490 --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/api/IStorageMultiplier.java @@ -0,0 +1,6 @@ +package com.github.gtexpert.gtmt.integration.storagedrawers.api; + +public interface IStorageMultiplier { + + long gtmt$getRawStorageMultiplier(); +} diff --git a/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/items/ItemGTMaterialUpgradeStorage.java b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/items/ItemGTMaterialUpgradeStorage.java new file mode 100644 index 0000000..1bfa0df --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/items/ItemGTMaterialUpgradeStorage.java @@ -0,0 +1,106 @@ +package com.github.gtexpert.gtmt.integration.storagedrawers.items; + +import static com.github.gtexpert.gtmt.integration.storagedrawers.items.StorageDrawersItems.upgradeStorageGT; + +import java.util.List; + +import javax.annotation.Nonnull; + +import net.minecraft.client.renderer.block.model.ModelResourceLocation; +import net.minecraft.client.resources.I18n; +import net.minecraft.client.util.ITooltipFlag; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; +import net.minecraft.world.World; +import net.minecraftforge.client.model.ModelLoader; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import com.jaquadro.minecraft.storagedrawers.item.ItemUpgrade; + +import gregtech.api.unification.material.Material; + +import com.github.gtexpert.gtmt.integration.storagedrawers.StorageDrawersUtil; +import com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades.IGTMaterialStorageUpgrade; +import com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades.UpgradeMaterialData; +import com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades.UpgradesMaterialRegistry; + +public class ItemGTMaterialUpgradeStorage extends ItemUpgrade implements IGTMaterialStorageUpgrade { + + private final UpgradesMaterialRegistry registry; + + public ItemGTMaterialUpgradeStorage(String registryName, String unlocalizedName, + UpgradesMaterialRegistry registry) { + super(registryName, unlocalizedName); + + this.registry = registry; + setMaxDamage(0); + setHasSubtypes(true); + setAllowMultiple(true); + } + + @Override + public int getMetadata(int damage) { + return damage; + } + + public UpgradeMaterialData getUpgradeMaterialData(ItemStack stack) { + return UpgradesMaterialRegistry.REGISTRY.getById(stack.getMetadata()); + } + + public Material getMaterial(ItemStack stack) { + return getUpgradeMaterialData(stack).getMaterial(); + } + + @Override + public int getStorageMultiplier(ItemStack stack) { + return getUpgradeMaterialData(stack).getMultiple(); + } + + @SideOnly(Side.CLIENT) + public static void registerModels() { + ModelLoader.setCustomMeshDefinition(upgradeStorageGT, stack -> getModelLocation()); + ModelLoader.registerItemVariants(upgradeStorageGT, getModelLocation()); + } + + @SideOnly(Side.CLIENT) + public static ModelResourceLocation getModelLocation() { + return new ModelResourceLocation(upgradeStorageGT.getRegistryName(), "inventory"); + } + + @Override + @SideOnly(Side.CLIENT) + public @NotNull String getItemStackDisplayName(@NotNull ItemStack stack) { + UpgradeMaterialData data = getUpgradeMaterialData(stack); + if (data == null) { + return super.getItemStackDisplayName(stack); + } + + String materialName = data.getMaterial().getUnlocalizedName(); + return I18n.format("gtmt.item.upgrade_storage.name", I18n.format(materialName)); + } + + @Override + @SideOnly(Side.CLIENT) + public void addInformation(@Nonnull ItemStack stack, @Nullable World world, List list, + ITooltipFlag advanced) { + UpgradeMaterialData data = getUpgradeMaterialData(stack); + if (data != null) { + int multi = data.getMultiple(); + list.add(I18n.format("storagedrawers.upgrade.description", multi)); + } + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(@NotNull CreativeTabs creativeTabs, @NotNull NonNullList list) { + if (isInCreativeTab(creativeTabs)) { + for (UpgradeMaterialData data : StorageDrawersUtil.UPGRADE_MATERIALS) + list.add(new ItemStack(this, 1, data.getId())); + } + } +} diff --git a/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/items/StorageDrawersItems.java b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/items/StorageDrawersItems.java new file mode 100644 index 0000000..4548eb7 --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/items/StorageDrawersItems.java @@ -0,0 +1,13 @@ +package com.github.gtexpert.gtmt.integration.storagedrawers.items; + +import com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades.UpgradesMaterialRegistry; + +public class StorageDrawersItems { + + public static ItemGTMaterialUpgradeStorage upgradeStorageGT; + + public static void init() { + upgradeStorageGT = new ItemGTMaterialUpgradeStorage("upgrade_storage_gt", "upgrade_storage_gt", + UpgradesMaterialRegistry.REGISTRY); + } +} diff --git a/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/recipes/UpgradesLoader.java b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/recipes/UpgradesLoader.java new file mode 100644 index 0000000..c3cedbb --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/recipes/UpgradesLoader.java @@ -0,0 +1,73 @@ +package com.github.gtexpert.gtmt.integration.storagedrawers.recipes; + +import static com.github.gtexpert.gtmt.integration.storagedrawers.items.StorageDrawersItems.upgradeStorageGT; + +import net.minecraft.item.ItemStack; + +import gregtech.api.items.metaitem.MetaItem; +import gregtech.api.recipes.ModHandler; +import gregtech.api.unification.material.Material; +import gregtech.api.unification.material.Materials; +import gregtech.api.unification.ore.OrePrefix; +import gregtech.api.unification.stack.UnificationEntry; +import gregtech.common.items.MetaItems; + +import com.github.gtexpert.gtmt.api.util.Mods; +import com.github.gtexpert.gtmt.integration.storagedrawers.StorageDrawersConfigHolder; +import com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades.UpgradesMaterialRegistry; + +public class UpgradesLoader { + + public static void upgradeStorage() { + // original + if (StorageDrawersConfigHolder.removeOriginal) { + ModHandler.removeRecipeByName(Mods.StorageDrawers.getResource("upgrade_storage_obsidian")); + ModHandler.removeRecipeByName(Mods.StorageDrawers.getResource("upgrade_storage_iron")); + ModHandler.removeRecipeByName(Mods.StorageDrawers.getResource("upgrade_storage_gold")); + ModHandler.removeRecipeByName(Mods.StorageDrawers.getResource("upgrade_storage_diamond")); + ModHandler.removeRecipeByName(Mods.StorageDrawers.getResource("upgrade_storage_emerald")); + } + // custom + MetaItem.MetaValueItem[] fieldGenerators = new MetaItem.MetaValueItem[] { + MetaItems.FIELD_GENERATOR_LV, MetaItems.FIELD_GENERATOR_MV, MetaItems.FIELD_GENERATOR_HV, + MetaItems.FIELD_GENERATOR_EV, MetaItems.FIELD_GENERATOR_IV, MetaItems.FIELD_GENERATOR_LuV, + MetaItems.FIELD_GENERATOR_ZPM, MetaItems.FIELD_GENERATOR_UV + }; + + UpgradesMaterialRegistry.REGISTRY.values().forEach(data -> { + Material material = data.getMaterial(); + int meta = data.getId(); + int tier = data.getTier(); + ItemStack output = new ItemStack(upgradeStorageGT, 1, meta); + String recipeName = "storage_upgrade_" + material.getName(); + + ModHandler.addShapedRecipe(true, recipeName, output, + "PSP", "SCS", "PTP", + 'P', new UnificationEntry(OrePrefix.plate, material), + 'S', new UnificationEntry(OrePrefix.screw, material), + 'C', Mods.StorageDrawers.getItem("upgrade_template"), + 'T', tier == -1 ? new UnificationEntry(OrePrefix.stickLong, material) : fieldGenerators[tier - 1]); + // convert recipe + if (material == Materials.Obsidian) { + addStorageUpgradeConvertRecipe(Mods.StorageDrawers.getItem("upgrade_storage", 1, 0), output, material); + } + if (material == Materials.Iron) { + addStorageUpgradeConvertRecipe(Mods.StorageDrawers.getItem("upgrade_storage", 1, 1), output, material); + } + if (material == Materials.Gold) { + addStorageUpgradeConvertRecipe(Mods.StorageDrawers.getItem("upgrade_storage", 1, 2), output, material); + } + if (material == Materials.Diamond) { + addStorageUpgradeConvertRecipe(Mods.StorageDrawers.getItem("upgrade_storage", 1, 3), output, material); + } + if (material == Materials.Emerald) { + addStorageUpgradeConvertRecipe(Mods.StorageDrawers.getItem("upgrade_storage", 1, 4), output, material); + } + }); + } + + private static void addStorageUpgradeConvertRecipe(ItemStack original, ItemStack custom, Material material) { + ModHandler.addShapelessRecipe("original_to_custom/" + material.getUnlocalizedName(), original, custom); + ModHandler.addShapelessRecipe("custom_to_original/" + material.getUnlocalizedName(), custom, original); + } +} diff --git a/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/storageupgrades/IGTMaterialStorageUpgrade.java b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/storageupgrades/IGTMaterialStorageUpgrade.java new file mode 100644 index 0000000..4cc57b1 --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/storageupgrades/IGTMaterialStorageUpgrade.java @@ -0,0 +1,8 @@ +package com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades; + +import net.minecraft.item.ItemStack; + +public interface IGTMaterialStorageUpgrade { + + int getStorageMultiplier(ItemStack stack); +} diff --git a/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/storageupgrades/StorageUpgradeColors.java b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/storageupgrades/StorageUpgradeColors.java new file mode 100644 index 0000000..7c5019c --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/storageupgrades/StorageUpgradeColors.java @@ -0,0 +1,37 @@ +package com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades; + +import net.minecraft.client.Minecraft; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +import gregtech.api.unification.material.Material; + +import com.github.gtexpert.gtmt.integration.storagedrawers.items.ItemGTMaterialUpgradeStorage; +import com.github.gtexpert.gtmt.integration.storagedrawers.items.StorageDrawersItems; + +@SideOnly(Side.CLIENT) +public class StorageUpgradeColors { + + public static void init() { + Minecraft.getMinecraft().getItemColors().registerItemColorHandler( + (stack, tintIndex) -> { + if (!(stack.getItem() instanceof ItemGTMaterialUpgradeStorage item)) { + return 0xFFFFFFFF; + } + + if (tintIndex % 2 == 0) { + return 0xFFFFFFFF; + } + + UpgradeMaterialData data = item.getUpgradeMaterialData(stack); + + if (data == null) { + return 0xFFFFFFFF; + } + Material material = item.getMaterial(stack); + + return material.getMaterialRGB(); + }, + StorageDrawersItems.upgradeStorageGT); + } +} diff --git a/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/storageupgrades/UpgradeMaterialData.java b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/storageupgrades/UpgradeMaterialData.java new file mode 100644 index 0000000..ce14b2a --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/storageupgrades/UpgradeMaterialData.java @@ -0,0 +1,34 @@ +package com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades; + +import gregtech.api.unification.material.Material; + +public class UpgradeMaterialData { + + private final Material material; + private final int id; + private final int multiple; + private final int tier; + + public UpgradeMaterialData(Material material, int id, int multiple, int tier) { + this.material = material; + this.id = id; + this.multiple = multiple; + this.tier = tier; + } + + public Material getMaterial() { + return material; + } + + public int getId() { + return id; + } + + public int getMultiple() { + return multiple; + } + + public int getTier() { + return tier; + } +} diff --git a/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/storageupgrades/UpgradesMaterialRegistry.java b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/storageupgrades/UpgradesMaterialRegistry.java new file mode 100644 index 0000000..b442f96 --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/integration/storagedrawers/storageupgrades/UpgradesMaterialRegistry.java @@ -0,0 +1,35 @@ +package com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades; + +import java.util.Collection; +import java.util.Map; +import java.util.TreeMap; + +import gregtech.api.unification.material.Material; + +public class UpgradesMaterialRegistry { + + private final Map map = new TreeMap<>(); + public static final UpgradesMaterialRegistry REGISTRY = new UpgradesMaterialRegistry(); + + private UpgradesMaterialRegistry() {} + + public void put(Material material, int id, int multiple, int tier) { + map.put(id, new UpgradeMaterialData(material, id, multiple, tier)); + } + + public void remove(int id) { + map.remove(id); + } + + public UpgradeMaterialData getById(int id) { + return map.get(id); + } + + public boolean isEmpty() { + return map.isEmpty(); + } + + public Collection values() { + return map.values(); + } +} diff --git a/src/main/java/com/github/gtexpert/gtmt/mixins/ModMixinLoader.java b/src/main/java/com/github/gtexpert/gtmt/mixins/ModMixinLoader.java index 1891b0e..eef1ee0 100644 --- a/src/main/java/com/github/gtexpert/gtmt/mixins/ModMixinLoader.java +++ b/src/main/java/com/github/gtexpert/gtmt/mixins/ModMixinLoader.java @@ -22,6 +22,7 @@ public class ModMixinLoader implements ILateMixinLoader { .put(Mods.Names.BETTER_BUILDERS_WANDS, true) .put(Mods.Names.CHISEL, true) .put(Mods.Names.TINKERS_CONSTRUCT, true) + .put(Mods.Names.STORAGE_DRAWERS, true) .build(); @SuppressWarnings("SimplifyStreamApiCallChains") diff --git a/src/main/java/com/github/gtexpert/gtmt/mixins/storagedrawers/AccessorTileEntityDrawers.java b/src/main/java/com/github/gtexpert/gtmt/mixins/storagedrawers/AccessorTileEntityDrawers.java new file mode 100644 index 0000000..e400936 --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/mixins/storagedrawers/AccessorTileEntityDrawers.java @@ -0,0 +1,13 @@ +package com.github.gtexpert.gtmt.mixins.storagedrawers; + +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.gen.Invoker; + +import com.jaquadro.minecraft.storagedrawers.block.tile.TileEntityDrawers; + +@Mixin(value = TileEntityDrawers.class, remap = false) +public interface AccessorTileEntityDrawers { + + @Invoker("getEffectiveDrawerCapacity") + int gtmt$invokeGetEffectiveDrawerCapacity(); +} diff --git a/src/main/java/com/github/gtexpert/gtmt/mixins/storagedrawers/DrawerUpgradeDataMixin.java b/src/main/java/com/github/gtexpert/gtmt/mixins/storagedrawers/DrawerUpgradeDataMixin.java new file mode 100644 index 0000000..0330da2 --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/mixins/storagedrawers/DrawerUpgradeDataMixin.java @@ -0,0 +1,173 @@ +package com.github.gtexpert.gtmt.mixins.storagedrawers; + +import javax.annotation.Nonnull; + +import net.minecraft.item.ItemStack; +import net.minecraft.util.math.MathHelper; + +import org.jetbrains.annotations.NotNull; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.Unique; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; + +import com.jaquadro.minecraft.storagedrawers.StorageDrawers; +import com.jaquadro.minecraft.storagedrawers.api.storage.EnumBasicDrawer; +import com.jaquadro.minecraft.storagedrawers.api.storage.IDrawer; +import com.jaquadro.minecraft.storagedrawers.block.tile.TileEntityDrawers; +import com.jaquadro.minecraft.storagedrawers.block.tile.tiledata.UpgradeData; +import com.jaquadro.minecraft.storagedrawers.core.ModItems; + +import com.github.gtexpert.gtmt.integration.storagedrawers.api.IStorageMultiplier; +import com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades.IGTMaterialStorageUpgrade; + +@Mixin(targets = "com.jaquadro.minecraft.storagedrawers.block.tile.TileEntityDrawers$DrawerUpgradeData", remap = false) +public abstract class DrawerUpgradeDataMixin extends UpgradeData { + + @Unique + private static final int MAX_MULTIPLIER = Integer.MAX_VALUE / + (StorageDrawers.config.getBlockBaseStorage(EnumBasicDrawer.FULL1.getUnlocalizedName()) * 64); + + protected DrawerUpgradeDataMixin() { + super(0); + } + + @Shadow(aliases = "this$0") + private TileEntityDrawers gtmt$outer; + + @Shadow + public abstract boolean canAddUpgrade(@Nonnull ItemStack upgrade); + + @Unique + private boolean gtmt$stackCapacityCheck(int stackCapacity) { + for (int i = 0; i < gtmt$outer.getDrawerCount(); i++) { + IDrawer drawer = gtmt$outer.getDrawer(i); + if (!drawer.isEnabled() || drawer.isEmpty()) { + continue; + } + + int addedItemCapacity = stackCapacity * drawer.getStoredItemStackSize(); + if (drawer.getMaxCapacity() - addedItemCapacity < drawer.getStoredItemCount()) { + return false; + } + } + + return true; + } + + @Unique + private int gtmt$getCustomMultiplier(ItemStack stack) { + if (stack == null || stack.isEmpty()) { + return 0; + } + + if (stack.getItem() instanceof IGTMaterialStorageUpgrade) { + return ((IGTMaterialStorageUpgrade) stack.getItem()).getStorageMultiplier(stack); + } + + return 0; + } + + @Unique + private long gtmt$getRawTotalMultiplier() { + return ((IStorageMultiplier) (Object) this).gtmt$getRawStorageMultiplier(); + } + + @Unique + private boolean gtmt$stackCapacityCheckByEffectiveMultiplier(int effectiveMultiplier) { + int stackCapacity = effectiveMultiplier * gtmt$outer.getEffectiveDrawerCapacity(); + + for (int i = 0; i < gtmt$outer.getDrawerCount(); i++) { + IDrawer drawer = gtmt$outer.getDrawer(i); + if (!drawer.isEnabled() || drawer.isEmpty()) { + continue; + } + + int addedItemCapacity = stackCapacity * drawer.getStoredItemStackSize(); + if (drawer.getMaxCapacity() - addedItemCapacity < drawer.getStoredItemCount()) { + return false; + } + } + + return true; + } + + @Inject(method = "canRemoveUpgrade", at = @At("HEAD"), cancellable = true) + private void gtmt$canRemoveUpgrade(int slot, CallbackInfoReturnable cir) { + ItemStack upgrade = this.getUpgrade(slot); + + if (upgrade == null || upgrade.isEmpty()) { + return; + } + + int currentCustomMultiplier = gtmt$getCustomMultiplier(upgrade); + + if (currentCustomMultiplier <= 0) { + return; + } + + long rawBefore = gtmt$getRawTotalMultiplier(); + long rawAfter = rawBefore - (long) currentCustomMultiplier; + if (rawAfter < 1L) { + rawAfter = 1L; + } + + int effBefore = (int) MathHelper.clamp(rawBefore, 1, MAX_MULTIPLIER); + int effAfter = (int) MathHelper.clamp(rawAfter, 1, MAX_MULTIPLIER); + + if (effBefore == effAfter) { + cir.setReturnValue(true); + return; + } + + cir.setReturnValue(gtmt$stackCapacityCheckByEffectiveMultiplier(effAfter)); + } + + @Inject(method = "canSwapUpgrade", at = @At("HEAD"), cancellable = true) + private void gtmt$canSwapUpgrade(int slot, @NotNull ItemStack add, CallbackInfoReturnable cir) { + ItemStack current = this.getUpgrade(slot); + if (current == null || current.isEmpty()) { + return; + } + + int currentCustomMultiplier = gtmt$getCustomMultiplier(current); + int addCustomMultiplier = gtmt$getCustomMultiplier(add); + + if (currentCustomMultiplier <= 0 && addCustomMultiplier <= 0) { + return; + } + + if (!this.canRemoveUpgrade(slot) || !this.canAddUpgrade(add)) { + cir.setReturnValue(false); + return; + } + + if (current.getItem() == ModItems.upgradeOneStack) { + cir.setReturnValue(true); + return; + } + + if (addCustomMultiplier > 0) { + cir.setReturnValue(true); + return; + } + + long rawBefore = gtmt$getRawTotalMultiplier(); + long rawAfter = rawBefore - (long) currentCustomMultiplier + (long) addCustomMultiplier; + if (rawAfter < 1L) { + rawAfter = 1L; + } + + int effBefore = (int) MathHelper.clamp(rawBefore, 1, MAX_MULTIPLIER); + int effAfter = (int) MathHelper.clamp(rawAfter, 1, MAX_MULTIPLIER); + + if (effBefore == effAfter) { + cir.setReturnValue(true); + return; + } + + cir.setReturnValue(gtmt$stackCapacityCheckByEffectiveMultiplier(effAfter)); + } +} diff --git a/src/main/java/com/github/gtexpert/gtmt/mixins/storagedrawers/SlotUpgradeMixin.java b/src/main/java/com/github/gtexpert/gtmt/mixins/storagedrawers/SlotUpgradeMixin.java new file mode 100644 index 0000000..6ee7508 --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/mixins/storagedrawers/SlotUpgradeMixin.java @@ -0,0 +1,44 @@ +package com.github.gtexpert.gtmt.mixins.storagedrawers; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Unique; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; + +import com.jaquadro.minecraft.storagedrawers.inventory.InventoryUpgrade; +import com.jaquadro.minecraft.storagedrawers.inventory.SlotUpgrade; + +import com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades.IGTMaterialStorageUpgrade; + +@Mixin(value = SlotUpgrade.class, remap = false) +public abstract class SlotUpgradeMixin extends Slot { + + public SlotUpgradeMixin(IInventory inventoryIn, int index, int xPosition, int yPosition) { + super(inventoryIn, index, xPosition, yPosition); + } + + @Unique + private boolean gtmt$isCustomStorageUpgrade(ItemStack stack) { + return stack != null && !stack.isEmpty() && stack.getItem() instanceof IGTMaterialStorageUpgrade; + } + + @Inject(method = "canTakeStack", at = @At("HEAD"), cancellable = true) + private void gtmt$canTakeStack(EntityPlayer player, CallbackInfoReturnable cir) { + if (!(inventory instanceof InventoryUpgrade inventoryUpgrade)) { + return; + } + + ItemStack stack = this.getStack(); + if (!gtmt$isCustomStorageUpgrade(stack)) { + return; + } + + cir.setReturnValue(inventoryUpgrade.canRemoveStorageUpgrade(this.getSlotIndex())); + } +} diff --git a/src/main/java/com/github/gtexpert/gtmt/mixins/storagedrawers/UpgradeDataMixin.java b/src/main/java/com/github/gtexpert/gtmt/mixins/storagedrawers/UpgradeDataMixin.java new file mode 100644 index 0000000..6e0e6ae --- /dev/null +++ b/src/main/java/com/github/gtexpert/gtmt/mixins/storagedrawers/UpgradeDataMixin.java @@ -0,0 +1,89 @@ +package com.github.gtexpert.gtmt.mixins.storagedrawers; + +import net.minecraft.item.ItemStack; +import net.minecraft.util.math.MathHelper; + +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.Unique; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; + +import com.jaquadro.minecraft.storagedrawers.StorageDrawers; +import com.jaquadro.minecraft.storagedrawers.api.storage.EnumBasicDrawer; +import com.jaquadro.minecraft.storagedrawers.block.tile.tiledata.UpgradeData; +import com.jaquadro.minecraft.storagedrawers.config.ConfigManager; +import com.jaquadro.minecraft.storagedrawers.core.ModItems; +import com.jaquadro.minecraft.storagedrawers.item.EnumUpgradeStorage; + +import com.github.gtexpert.gtmt.integration.storagedrawers.api.IStorageMultiplier; +import com.github.gtexpert.gtmt.integration.storagedrawers.storageupgrades.IGTMaterialStorageUpgrade; + +@Mixin(value = UpgradeData.class, remap = false) +public abstract class UpgradeDataMixin implements IStorageMultiplier { + + @Shadow + private ItemStack[] upgrades; + @Shadow + private int storageMultiplier; + @Unique + private long gtmt$rawStorageMultiplier = 1; + @Unique + private static final int MAX_MULTIPLIER = Integer.MAX_VALUE / + (StorageDrawers.config.getBlockBaseStorage(EnumBasicDrawer.FULL1.getUnlocalizedName()) * 64); + + @Override + public long gtmt$getRawStorageMultiplier() { + return gtmt$rawStorageMultiplier; + } + + @Unique + private int gtmt$getMultiplierOf(ItemStack stack) { + if (stack == null || stack.isEmpty()) { + return 0; + } + + if (stack.getItem() == ModItems.upgradeStorage) { + int level = EnumUpgradeStorage.byMetadata(stack.getMetadata()).getLevel(); + return StorageDrawers.config.getStorageUpgradeMultiplier(level); + } + + if (stack.getItem() instanceof IGTMaterialStorageUpgrade upgrade) { + return upgrade.getStorageMultiplier(stack); + } + + return 0; + } + + @Unique + private int gtmt$clampEffectiveMultiplier(long raw) { + if (raw <= 1L) { + return 1; + } + if (raw >= MAX_MULTIPLIER) { + return MAX_MULTIPLIER; + } + return (int) raw; + } + + @Inject(method = "syncStorageMultiplier", + at = @At("HEAD"), + cancellable = true) + private void gtmt$syncStorageMultiplier(CallbackInfo ci) { + ConfigManager config = StorageDrawers.config; + long raw = 0L; + + for (ItemStack stack : upgrades) { + raw += gtmt$getMultiplierOf(stack); + } + + if (raw <= 0) { + raw = config.getStorageUpgradeMultiplier(1); + } + + this.gtmt$rawStorageMultiplier = raw; + this.storageMultiplier = (int) MathHelper.clamp(raw, 1, MAX_MULTIPLIER); + ci.cancel(); + } +} diff --git a/src/main/java/com/github/gtexpert/gtmt/modules/Modules.java b/src/main/java/com/github/gtexpert/gtmt/modules/Modules.java index 94f7960..f7d5255 100644 --- a/src/main/java/com/github/gtexpert/gtmt/modules/Modules.java +++ b/src/main/java/com/github/gtexpert/gtmt/modules/Modules.java @@ -35,6 +35,7 @@ public class Modules implements IModuleContainer { public static final String MODULE_AVARITIA = "avaritia_integration"; public static final String MODULE_TC = "tc_integration"; public static final String MODULE_TE = "te_integration"; + public static final String MODULE_DRAWERS = "storage_drawers_integration"; @Override public String getID() { diff --git a/src/main/resources/assets/gtmt/lang/en_us.lang b/src/main/resources/assets/gtmt/lang/en_us.lang index 672dafd..1943457 100644 --- a/src/main/resources/assets/gtmt/lang/en_us.lang +++ b/src/main/resources/assets/gtmt/lang/en_us.lang @@ -4,6 +4,9 @@ gt.tool.class.chisel=Chisel item.gt.tool.wand.name=%s Wand gt.tool.class.wand=Wand +item.upgrade_storage.name=Storage Upgrade +gtmt.item.upgrade_storage.name=Storage Upgrade (%s) + # singleblock # Auto Chisel gtmt.machine.auto_chisel.lv.name=Basic Auto Chisel diff --git a/src/main/resources/assets/gtmt/lang/ja_jp.lang b/src/main/resources/assets/gtmt/lang/ja_jp.lang index 2bd6ae2..c194785 100644 --- a/src/main/resources/assets/gtmt/lang/ja_jp.lang +++ b/src/main/resources/assets/gtmt/lang/ja_jp.lang @@ -4,6 +4,9 @@ gt.tool.class.chisel=チゼル item.gt.tool.wand.name=%sのワンド gt.tool.class.wand=ワンド +item.upgrade_storage.name=容量キット +gtmt.item.upgrade_storage.name=容量キット (%s) + # singleblock # Auto Chisel gtmt.machine.auto_chisel.lv.name=基本型自動彫刻機 diff --git a/src/main/resources/assets/gtmt/models/item/upgrade_storage_gt.json b/src/main/resources/assets/gtmt/models/item/upgrade_storage_gt.json new file mode 100644 index 0000000..92c91d7 --- /dev/null +++ b/src/main/resources/assets/gtmt/models/item/upgrade_storage_gt.json @@ -0,0 +1,7 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "gtmt:items/storage_drawers/upgrade_storage_base", + "layer1": "gtmt:items/storage_drawers/upgrade_storage_material" + } +} diff --git a/src/main/resources/assets/gtmt/textures/items/storage_drawers/upgrade_storage_base.png b/src/main/resources/assets/gtmt/textures/items/storage_drawers/upgrade_storage_base.png new file mode 100644 index 0000000..cca0d78 Binary files /dev/null and b/src/main/resources/assets/gtmt/textures/items/storage_drawers/upgrade_storage_base.png differ diff --git a/src/main/resources/assets/gtmt/textures/items/storage_drawers/upgrade_storage_material.png b/src/main/resources/assets/gtmt/textures/items/storage_drawers/upgrade_storage_material.png new file mode 100644 index 0000000..41f2749 Binary files /dev/null and b/src/main/resources/assets/gtmt/textures/items/storage_drawers/upgrade_storage_material.png differ diff --git a/src/main/resources/mixins.gtmt.storagedrawers.json b/src/main/resources/mixins.gtmt.storagedrawers.json new file mode 100644 index 0000000..8af1d88 --- /dev/null +++ b/src/main/resources/mixins.gtmt.storagedrawers.json @@ -0,0 +1,13 @@ +{ + "package": "com.github.gtexpert.gtmt.mixins.storagedrawers", + "refmap": "mixins.gtmt.refmap.json", + "target": "@env(DEFAULT)", + "minVersion": "0.8", + "compatibilityLevel": "JAVA_8", + "mixins": [ + "UpgradeDataMixin", + "DrawerUpgradeDataMixin", + "AccessorTileEntityDrawers", + "SlotUpgradeMixin" + ] +}