aboutsummaryrefslogtreecommitdiff
path: root/src/main/java/ggfab
diff options
context:
space:
mode:
Diffstat (limited to 'src/main/java/ggfab')
-rw-r--r--src/main/java/ggfab/BlockIcons.java45
-rw-r--r--src/main/java/ggfab/ComponentRecipeLoader.java57
-rw-r--r--src/main/java/ggfab/ConfigurationHandler.java52
-rw-r--r--src/main/java/ggfab/GGConstants.java16
-rw-r--r--src/main/java/ggfab/GGItemList.java205
-rw-r--r--src/main/java/ggfab/GigaGramFab.java185
-rw-r--r--src/main/java/ggfab/SingleUseToolRecipeLoader.java102
-rw-r--r--src/main/java/ggfab/api/GGFabRecipeMaps.java64
-rw-r--r--src/main/java/ggfab/api/GigaGramFabAPI.java30
-rw-r--r--src/main/java/ggfab/items/GGMetaItemDumbItems.java153
-rw-r--r--src/main/java/ggfab/mte/MTEAdvAssLine.java1106
-rw-r--r--src/main/java/ggfab/mte/MTELinkedInputBus.java683
-rw-r--r--src/main/java/ggfab/mui/ClickableTextWidget.java58
-rw-r--r--src/main/java/ggfab/util/GGUtils.java78
-rw-r--r--src/main/java/ggfab/util/OverclockHelper.java75
15 files changed, 2909 insertions, 0 deletions
diff --git a/src/main/java/ggfab/BlockIcons.java b/src/main/java/ggfab/BlockIcons.java
new file mode 100644
index 0000000000..7017f53f7e
--- /dev/null
+++ b/src/main/java/ggfab/BlockIcons.java
@@ -0,0 +1,45 @@
+package ggfab;
+
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.ResourceLocation;
+
+import gregtech.api.GregTechAPI;
+import gregtech.api.interfaces.IIconContainer;
+
+public enum BlockIcons implements IIconContainer, Runnable {
+
+ OVERLAY_FRONT_ADV_ASSLINE_ACTIVE,
+ OVERLAY_FRONT_ADV_ASSLINE_ACTIVE_GLOW,
+ OVERLAY_FRONT_ADV_ASSLINE_STUCK,
+ OVERLAY_FRONT_ADV_ASSLINE_STUCK_GLOW,
+ OVERLAY_FRONT_ADV_ASSLINE,
+ OVERLAY_FRONT_ADV_ASSLINE_GLOW,;
+
+ public static final String RES_PATH = GGConstants.MODID + ":";
+ private IIcon mIcon;
+
+ BlockIcons() {
+ GregTechAPI.sGTBlockIconload.add(this);
+ }
+
+ @Override
+ public IIcon getIcon() {
+ return mIcon;
+ }
+
+ @Override
+ public IIcon getOverlayIcon() {
+ return null;
+ }
+
+ @Override
+ public ResourceLocation getTextureFile() {
+ return TextureMap.locationBlocksTexture;
+ }
+
+ @Override
+ public void run() {
+ mIcon = GregTechAPI.sBlockIcons.registerIcon(RES_PATH + "iconsets/" + this);
+ }
+}
diff --git a/src/main/java/ggfab/ComponentRecipeLoader.java b/src/main/java/ggfab/ComponentRecipeLoader.java
new file mode 100644
index 0000000000..7345ff89f4
--- /dev/null
+++ b/src/main/java/ggfab/ComponentRecipeLoader.java
@@ -0,0 +1,57 @@
+package ggfab;
+
+import static gregtech.api.recipe.RecipeMaps.assemblerRecipes;
+import static gregtech.api.util.GTRecipeBuilder.HOURS;
+import static gregtech.api.util.GTRecipeBuilder.MINUTES;
+import static gregtech.api.util.GTRecipeBuilder.SECONDS;
+import static gregtech.api.util.GTRecipeConstants.AssemblyLine;
+import static gregtech.api.util.GTRecipeConstants.RESEARCH_ITEM;
+import static gregtech.api.util.GTRecipeConstants.RESEARCH_TIME;
+
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+
+import gregtech.api.enums.GTValues;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.util.GTOreDictUnificator;
+import gregtech.api.util.GTUtility;
+
+class ComponentRecipeLoader implements Runnable {
+
+ @Override
+ public void run() {
+ Fluid solderIndalloy = FluidRegistry.getFluid("molten.indalloy140");
+
+ GTValues.RA.stdBuilder()
+ .metadata(RESEARCH_ITEM, ItemList.Machine_Multi_Assemblyline.get(1L))
+ .metadata(RESEARCH_TIME, 1 * HOURS + 6 * MINUTES)
+ .itemInputs(
+ ItemList.Machine_Multi_Assemblyline.get(1L),
+ new Object[] { OrePrefixes.circuit.get(Materials.LuV), 2 },
+ new Object[] { OrePrefixes.circuit.get(Materials.IV), 4 },
+ new Object[] { OrePrefixes.circuit.get(Materials.EV), 8 },
+ ItemList.Automation_ChestBuffer_LuV.get(1L))
+ .fluidInputs(new FluidStack(solderIndalloy, 1296), Materials.Lubricant.getFluid(2000))
+ .itemOutputs(GGItemList.AdvAssLine.get(1L))
+ .eut(6_000)
+ .duration(10 * MINUTES)
+ .addTo(AssemblyLine);
+
+ GTValues.RA.stdBuilder()
+ .itemInputs(
+ ItemList.Hatch_Input_Bus_IV.get(1L),
+ ItemList.Emitter_IV.get(1L),
+ ItemList.Sensor_IV.get(1L),
+ GTOreDictUnificator.get(OrePrefixes.plateDense, Materials.Enderium, 1L),
+ GTUtility.getIntegratedCircuit(12))
+ .itemOutputs(GGItemList.LinkedInputBus.get(1L))
+ .fluidInputs(Materials.Polybenzimidazole.getMolten(144L))
+ .duration(30 * SECONDS)
+ .eut(GTValues.VP[5])
+ .addTo(assemblerRecipes);
+
+ }
+}
diff --git a/src/main/java/ggfab/ConfigurationHandler.java b/src/main/java/ggfab/ConfigurationHandler.java
new file mode 100644
index 0000000000..a1f83c8bbf
--- /dev/null
+++ b/src/main/java/ggfab/ConfigurationHandler.java
@@ -0,0 +1,52 @@
+package ggfab;
+
+import java.io.File;
+import java.util.Map;
+
+import net.minecraftforge.common.config.ConfigCategory;
+import net.minecraftforge.common.config.Configuration;
+import net.minecraftforge.common.config.Property;
+
+public enum ConfigurationHandler {
+
+ INSTANCE;
+
+ private Configuration config;
+ private float laserOCPenaltyFactor;
+
+ void init(File f) {
+ config = new Configuration(f);
+ loadConfig();
+ setLanguageKeys();
+ }
+
+ private void setLanguageKeys() {
+ for (String categoryName : config.getCategoryNames()) {
+ ConfigCategory category = config.getCategory(categoryName);
+ category.setLanguageKey("ggfab.config." + categoryName);
+ for (Map.Entry<String, Property> entry : category.entrySet()) {
+ entry.getValue()
+ .setLanguageKey(String.format("%s.%s", category.getLanguagekey(), entry.getKey()));
+ }
+ }
+ }
+
+ private void loadConfig() {
+ laserOCPenaltyFactor = config.getFloat(
+ "advasslinePenaltyFactor",
+ "common.balancing",
+ 0.3f,
+ 0f,
+ 10f,
+ "Laser overclock penalty factor. This will incredibly change the game balance. Even a small step from 0.2 to 0.3 can have very significant impact. Tweak with caution!");
+ config.save();
+ }
+
+ public Configuration getConfig() {
+ return config;
+ }
+
+ public float getLaserOCPenaltyFactor() {
+ return laserOCPenaltyFactor;
+ }
+}
diff --git a/src/main/java/ggfab/GGConstants.java b/src/main/java/ggfab/GGConstants.java
new file mode 100644
index 0000000000..4165d687d8
--- /dev/null
+++ b/src/main/java/ggfab/GGConstants.java
@@ -0,0 +1,16 @@
+package ggfab;
+
+import net.minecraft.util.EnumChatFormatting;
+
+import gregtech.GT_Version;
+
+public class GGConstants {
+
+ public static final String MODID = "ggfab";
+ public static final String RES_PATH_ITEM = MODID + ":";
+ public static final String MODNAME = "GigaGramFab";
+ public static final String VERSION = GT_Version.VERSION;
+
+ public static final String GGMARK = EnumChatFormatting.GOLD + "GigaGram" + EnumChatFormatting.RESET + "Fab";
+ public static final String GGMARK_TOOLTIP = "Added by " + GGMARK;
+}
diff --git a/src/main/java/ggfab/GGItemList.java b/src/main/java/ggfab/GGItemList.java
new file mode 100644
index 0000000000..5698acf683
--- /dev/null
+++ b/src/main/java/ggfab/GGItemList.java
@@ -0,0 +1,205 @@
+package ggfab;
+
+import static gregtech.api.enums.GTValues.W;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+import gregtech.api.interfaces.IItemContainer;
+import gregtech.api.util.GTModHandler;
+import gregtech.api.util.GTOreDictUnificator;
+import gregtech.api.util.GTUtility;
+
+public enum GGItemList implements IItemContainer {
+
+ LinkedInputBus,
+ AdvAssLine,
+ // region single use tool
+ ToolCast_MV,
+ ToolCast_HV,
+ ToolCast_EV,
+ // order matters, do not insert randomly like a n00b
+ One_Use_craftingToolFile,
+ One_Use_craftingToolWrench,
+ One_Use_craftingToolCrowbar,
+ One_Use_craftingToolWireCutter,
+ One_Use_craftingToolHardHammer,
+ One_Use_craftingToolSoftHammer,
+ One_Use_craftingToolScrewdriver,
+ One_Use_craftingToolSaw,
+ Shape_One_Use_craftingToolFile,
+ Shape_One_Use_craftingToolWrench,
+ Shape_One_Use_craftingToolCrowbar,
+ Shape_One_Use_craftingToolWireCutter,
+ Shape_One_Use_craftingToolHardHammer,
+ Shape_One_Use_craftingToolSoftHammer,
+ Shape_One_Use_craftingToolScrewdriver,
+ Shape_One_Use_craftingToolSaw,
+ // ordered section ends
+ // endregion
+ //
+ ;
+
+ private ItemStack mStack;
+ private boolean mHasNotBeenSet = true;
+
+ @Override
+ public IItemContainer set(Item aItem) {
+ mHasNotBeenSet = false;
+ if (aItem == null) {
+ return this;
+ }
+ ItemStack aStack = new ItemStack(aItem, 1, 0);
+ mStack = GTUtility.copyAmount(1, aStack);
+ return this;
+ }
+
+ @Override
+ public IItemContainer hidden() {
+ codechicken.nei.api.API.hideItem(get(1L));
+ return this;
+ }
+
+ @Override
+ public IItemContainer set(ItemStack aStack) {
+ mHasNotBeenSet = false;
+ mStack = GTUtility.copyAmount(1, aStack);
+ return this;
+ }
+
+ @Override
+ public Item getItem() {
+ if (mHasNotBeenSet) {
+ throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!");
+ }
+ if (GTUtility.isStackInvalid(mStack)) {
+ return null;
+ }
+ return mStack.getItem();
+ }
+
+ @Override
+ public Block getBlock() {
+ if (mHasNotBeenSet) {
+ throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!");
+ }
+ return GTUtility.getBlockFromStack(new ItemStack(getItem()));
+ }
+
+ @Override
+ public final boolean hasBeenSet() {
+ return !mHasNotBeenSet;
+ }
+
+ @Override
+ public boolean isStackEqual(Object aStack) {
+ return isStackEqual(aStack, false, false);
+ }
+
+ @Override
+ public boolean isStackEqual(Object aStack, boolean aWildcard, boolean aIgnoreNBT) {
+ if (GTUtility.isStackInvalid(aStack)) {
+ return false;
+ }
+ return GTUtility.areUnificationsEqual((ItemStack) aStack, aWildcard ? getWildcard(1) : get(1), aIgnoreNBT);
+ }
+
+ @Override
+ public ItemStack get(long aAmount, Object... aReplacements) {
+ if (mHasNotBeenSet) {
+ throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!");
+ }
+ if (GTUtility.isStackInvalid(mStack)) {
+ return GTUtility.copyAmount(aAmount, aReplacements);
+ }
+ return GTUtility.copyAmount(aAmount, GTOreDictUnificator.get(mStack));
+ }
+
+ @Override
+ public ItemStack getWildcard(long aAmount, Object... aReplacements) {
+ if (mHasNotBeenSet) {
+ throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!");
+ }
+ if (GTUtility.isStackInvalid(mStack)) {
+ return GTUtility.copyAmount(aAmount, aReplacements);
+ }
+ return GTUtility.copyAmountAndMetaData(aAmount, W, GTOreDictUnificator.get(mStack));
+ }
+
+ @Override
+ public ItemStack getUndamaged(long aAmount, Object... aReplacements) {
+ if (mHasNotBeenSet) {
+ throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!");
+ }
+ if (GTUtility.isStackInvalid(mStack)) {
+ return GTUtility.copyAmount(aAmount, aReplacements);
+ }
+ return GTUtility.copyAmountAndMetaData(aAmount, 0, GTOreDictUnificator.get(mStack));
+ }
+
+ @Override
+ public ItemStack getAlmostBroken(long aAmount, Object... aReplacements) {
+ if (mHasNotBeenSet) {
+ throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!");
+ }
+ if (GTUtility.isStackInvalid(mStack)) {
+ return GTUtility.copyAmount(aAmount, aReplacements);
+ }
+ return GTUtility.copyAmountAndMetaData(aAmount, mStack.getMaxDamage() - 1, GTOreDictUnificator.get(mStack));
+ }
+
+ @Override
+ public ItemStack getWithName(long aAmount, String aDisplayName, Object... aReplacements) {
+ ItemStack rStack = get(1, aReplacements);
+ if (GTUtility.isStackInvalid(rStack)) {
+ return null;
+ }
+ rStack.setStackDisplayName(aDisplayName);
+ return GTUtility.copyAmount(aAmount, rStack);
+ }
+
+ @Override
+ public ItemStack getWithCharge(long aAmount, int aEnergy, Object... aReplacements) {
+ ItemStack rStack = get(1, aReplacements);
+ if (GTUtility.isStackInvalid(rStack)) {
+ return null;
+ }
+ GTModHandler.chargeElectricItem(rStack, aEnergy, Integer.MAX_VALUE, true, false);
+ return GTUtility.copyAmount(aAmount, rStack);
+ }
+
+ @Override
+ public ItemStack getWithDamage(long aAmount, long aMetaValue, Object... aReplacements) {
+ if (mHasNotBeenSet) {
+ throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!");
+ }
+ if (GTUtility.isStackInvalid(mStack)) {
+ return GTUtility.copyAmount(aAmount, aReplacements);
+ }
+ return GTUtility.copyAmountAndMetaData(aAmount, aMetaValue, GTOreDictUnificator.get(mStack));
+ }
+
+ @Override
+ public IItemContainer registerOre(Object... aOreNames) {
+ if (mHasNotBeenSet) {
+ throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!");
+ }
+ for (Object tOreName : aOreNames) {
+ GTOreDictUnificator.registerOre(tOreName, get(1));
+ }
+ return this;
+ }
+
+ @Override
+ public IItemContainer registerWildcardAsOre(Object... aOreNames) {
+ if (mHasNotBeenSet) {
+ throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!");
+ }
+ for (Object tOreName : aOreNames) {
+ GTOreDictUnificator.registerOre(tOreName, getWildcard(1));
+ }
+ return this;
+ }
+
+}
diff --git a/src/main/java/ggfab/GigaGramFab.java b/src/main/java/ggfab/GigaGramFab.java
new file mode 100644
index 0000000000..8fc8ef26a9
--- /dev/null
+++ b/src/main/java/ggfab/GigaGramFab.java
@@ -0,0 +1,185 @@
+package ggfab;
+
+import static gregtech.api.enums.ToolDictNames.*;
+import static gregtech.common.items.IDMetaTool01.*;
+import static gregtech.common.items.MetaGeneratedTool01.*;
+
+import net.minecraft.item.ItemStack;
+
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import ggfab.api.GGFabRecipeMaps;
+import ggfab.api.GigaGramFabAPI;
+import ggfab.items.GGMetaItemDumbItems;
+import ggfab.mte.MTEAdvAssLine;
+import ggfab.mte.MTELinkedInputBus;
+import ggfab.util.GGUtils;
+import gregtech.api.GregTechAPI;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.SoundResource;
+import gregtech.api.metatileentity.implementations.MTEBasicMachineWithRecipe;
+import gregtech.api.util.ProcessingArrayManager;
+
+@Mod(
+ modid = GGConstants.MODID,
+ version = GGConstants.VERSION,
+ name = GGConstants.MODNAME,
+ acceptedMinecraftVersions = "[1.7.10]",
+ dependencies = "required-after:IC2;required-before:gregtech")
+public class GigaGramFab {
+
+ public GigaGramFab() {
+ // initialize the textures
+ // noinspection ResultOfMethodCallIgnored
+ BlockIcons.OVERLAY_FRONT_ADV_ASSLINE.name();
+ }
+
+ @Mod.EventHandler
+ public void preInit(FMLPreInitializationEvent event) {
+ GregTechAPI.sAfterGTPreload.add(() -> {
+ GGItemList.AdvAssLine
+ .set(new MTEAdvAssLine(13532, "ggfab.machine.adv_assline", "Advanced Assembly Line").getStackForm(1));
+ GGItemList.LinkedInputBus.set(
+ new MTELinkedInputBus(13533, "ggfab.machine.linked_input_bus", "Linked Input Bus", 5).getStackForm(1));
+ GGItemList.ToolCast_MV.set(
+ new MTEBasicMachineWithRecipe(
+ 13534,
+ "ggfab.toolcast.tier.mv",
+ "Basic Tool Casting Machine",
+ 2,
+ "Cheap Crafting Tool for you!",
+ GGFabRecipeMaps.toolCastRecipes,
+ 1,
+ 4,
+ 32000,
+ SoundResource.NONE,
+ MTEBasicMachineWithRecipe.SpecialEffects.MAIN_RANDOM_SPARKS,
+ "TOOL_CAST",
+ new Object[] { "PGP", "WMW", "CBC", 'M', MTEBasicMachineWithRecipe.X.HULL, 'P',
+ MTEBasicMachineWithRecipe.X.PUMP, 'C', MTEBasicMachineWithRecipe.X.CIRCUIT, 'W',
+ MTEBasicMachineWithRecipe.X.WIRE, 'G', MTEBasicMachineWithRecipe.X.GLASS, 'B',
+ ItemList.Shape_Empty.get(1L) }).getStackForm(1L));
+ GGItemList.ToolCast_HV.set(
+ new MTEBasicMachineWithRecipe(
+ 13535,
+ "ggfab.toolcast.tier.hv",
+ "Advanced Tool Casting Machine",
+ 3,
+ "Cheap Crafting Tool for you!",
+ GGFabRecipeMaps.toolCastRecipes,
+ 1,
+ 4,
+ 64000,
+ SoundResource.NONE,
+ MTEBasicMachineWithRecipe.SpecialEffects.MAIN_RANDOM_SPARKS,
+ "TOOL_CAST",
+ new Object[] { "PGP", "WMW", "CBC", 'M', MTEBasicMachineWithRecipe.X.HULL, 'P',
+ MTEBasicMachineWithRecipe.X.PUMP, 'C', MTEBasicMachineWithRecipe.X.CIRCUIT, 'W',
+ MTEBasicMachineWithRecipe.X.WIRE, 'G', MTEBasicMachineWithRecipe.X.GLASS, 'B',
+ ItemList.Shape_Empty.get(1L) }).getStackForm(1L));
+ GGItemList.ToolCast_EV.set(
+ new MTEBasicMachineWithRecipe(
+ 13536,
+ "ggfab.toolcast.tier.ev",
+ "Master Tool Casting Machine",
+ 4,
+ "Cheap Crafting Tool for you!",
+ GGFabRecipeMaps.toolCastRecipes,
+ 1,
+ 4,
+ 128000,
+ SoundResource.NONE,
+ MTEBasicMachineWithRecipe.SpecialEffects.MAIN_RANDOM_SPARKS,
+ "TOOL_CAST",
+ new Object[] { "PGP", "WMW", "CBC", 'M', MTEBasicMachineWithRecipe.X.HULL, 'P',
+ MTEBasicMachineWithRecipe.X.PUMP, 'C', MTEBasicMachineWithRecipe.X.CIRCUIT, 'W',
+ MTEBasicMachineWithRecipe.X.WIRE, 'G', MTEBasicMachineWithRecipe.X.GLASS, 'B',
+ ItemList.Shape_Empty.get(1L) }).getStackForm(1L));
+ long plate = OrePrefixes.plate.mMaterialAmount, ingot = OrePrefixes.ingot.mMaterialAmount,
+ screw = OrePrefixes.screw.mMaterialAmount, rod = OrePrefixes.stick.mMaterialAmount;
+ GigaGramFabAPI.addSingleUseToolType(craftingToolFile, INSTANCE.mToolStats.get((short) FILE.ID), 2 * plate);
+ GigaGramFabAPI
+ .addSingleUseToolType(craftingToolWrench, INSTANCE.mToolStats.get((short) WRENCH.ID), 6 * ingot);
+ GigaGramFabAPI
+ .addSingleUseToolType(craftingToolCrowbar, INSTANCE.mToolStats.get((short) CROWBAR.ID), 3 * rod);
+ GigaGramFabAPI.addSingleUseToolType(
+ craftingToolWireCutter,
+ INSTANCE.mToolStats.get((short) WIRECUTTER.ID),
+ 3 * plate + 2 * rod + screw);
+ GigaGramFabAPI.addSingleUseToolType(
+ craftingToolHardHammer,
+ INSTANCE.mToolStats.get((short) HARDHAMMER.ID),
+ 6 * ingot);
+ GigaGramFabAPI.addSingleUseToolType(
+ craftingToolSoftHammer,
+ INSTANCE.mToolStats.get((short) SOFTMALLET.ID),
+ 6 * ingot);
+ GigaGramFabAPI.addSingleUseToolType(
+ craftingToolScrewdriver,
+ INSTANCE.mToolStats.get((short) SCREWDRIVER.ID),
+ 2 * rod);
+ GigaGramFabAPI.addSingleUseToolType(craftingToolSaw, INSTANCE.mToolStats.get((short) SAW.ID), 2 * plate);
+ ProcessingArrayManager.addRecipeMapToPA("ggfab.toolcast", GGFabRecipeMaps.toolCastRecipes);
+ });
+ GregTechAPI.sBeforeGTPostload.add(new ComponentRecipeLoader());
+ GregTechAPI.sBeforeGTPostload.add(new SingleUseToolRecipeLoader());
+ ConfigurationHandler.INSTANCE.init(event.getSuggestedConfigurationFile());
+
+ initDumbItem1();
+ }
+
+ @Mod.EventHandler
+ public void init(FMLInitializationEvent event) {}
+
+ @Mod.EventHandler
+ public void postInit(FMLPostInitializationEvent event) {}
+
+ private void initDumbItem1() {
+ GGMetaItemDumbItems i1 = new GGMetaItemDumbItems("ggfab.d1");
+ int id = 0;
+ {
+ int idShape = 30;
+ final int budget = idShape;
+ String prefix = "One_Use_craftingTool";
+ String prefix2 = "Shape_One_Use_craftingTool";
+ for (GGItemList i : GGItemList.values()) {
+ ItemStack stack = null;
+ if (i.name()
+ .startsWith(prefix)) {
+ stack = i1.addItem(
+ id++,
+ "Single Use " + GGUtils.processSentence(
+ i.name()
+ .substring(prefix.length()),
+ ' ',
+ true,
+ true),
+ null,
+ i,
+ i.name()
+ .substring("One_Use_".length()));
+ } else if (i.name()
+ .startsWith(prefix2)) {
+ stack = i1.addItem(
+ idShape++,
+ "Tool Casting Mold (" + GGUtils.processSentence(
+ i.name()
+ .substring(prefix2.length()),
+ ' ',
+ true,
+ true) + ")",
+ null,
+ i);
+ }
+ if (stack != null) {
+ i.set(stack);
+ }
+ }
+ if (id >= budget || idShape >= 2 * budget || idShape - id != budget) throw new AssertionError();
+ id = budget * 2;
+ }
+ }
+}
diff --git a/src/main/java/ggfab/SingleUseToolRecipeLoader.java b/src/main/java/ggfab/SingleUseToolRecipeLoader.java
new file mode 100644
index 0000000000..c79f792cfc
--- /dev/null
+++ b/src/main/java/ggfab/SingleUseToolRecipeLoader.java
@@ -0,0 +1,102 @@
+package ggfab;
+
+import static gregtech.api.enums.ToolDictNames.*;
+import static gregtech.api.util.GTRecipeBuilder.SECONDS;
+
+import ggfab.api.GGFabRecipeMaps;
+import ggfab.api.GigaGramFabAPI;
+import gregtech.api.enums.GTValues;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.TierEU;
+import gregtech.api.enums.ToolDictNames;
+import gregtech.api.interfaces.IToolStats;
+import gregtech.api.util.GTModHandler;
+import gregtech.api.util.GTUtility;
+
+class SingleUseToolRecipeLoader implements Runnable {
+
+ @Override
+ public void run() {
+ ToolDictNames[] hardTools = new ToolDictNames[] { craftingToolHardHammer, craftingToolScrewdriver,
+ craftingToolWrench, craftingToolCrowbar, craftingToolWireCutter, craftingToolFile, craftingToolSaw };
+ ToolDictNames[] softTools = new ToolDictNames[] { craftingToolSoftHammer };
+ addSingleUseToolRecipe(Materials.Steel, hardTools);
+ addSingleUseToolRecipe(Materials.Silver, 5000, hardTools);
+ addSingleUseToolRecipe(Materials.VanadiumSteel, hardTools);
+ addSingleUseToolRecipe(Materials.TungstenSteel, hardTools);
+ addSingleUseToolRecipe(Materials.HSSG, hardTools);
+ addSingleUseToolRecipe(Materials.Rubber, softTools);
+ addSingleUseToolRecipe(Materials.StyreneButadieneRubber, softTools);
+ addSingleUseToolRecipe(Materials.Polybenzimidazole, softTools);
+
+ String prefix = "Shape_One_Use_";
+ for (GGItemList value : GGItemList.values()) {
+ if (!value.name()
+ .startsWith(prefix)) {
+ continue;
+ }
+ ToolDictNames type = ToolDictNames.valueOf(
+ value.name()
+ .substring(prefix.length()));
+ GTModHandler
+ .addCraftingRecipe(value.get(1L), new Object[] { "h", "P", "I", 'P', ItemList.Shape_Empty, 'I', type });
+ }
+ }
+
+ private void addSingleUseToolRecipe(Materials material, ToolDictNames... types) {
+ addSingleUseToolRecipe(material, 10000, types);
+ }
+
+ private static long findNiceFactor(long fluids, long count) {
+ long end = Math.min(fluids, count);
+ for (long i = count / 256; i < end; i++) {
+ if (fluids % i == 0 && count % i == 0 && count / i < 256) return i;
+ }
+ return -1;
+ }
+
+ private void addSingleUseToolRecipe(Materials material, int outputModifier, ToolDictNames... types) {
+ if (material.mStandardMoltenFluid == null) {
+ throw new IllegalArgumentException("material does not have molten fluid form");
+ }
+ for (ToolDictNames type : types) {
+ IToolStats stats = GigaGramFabAPI.SINGLE_USE_TOOLS.get(type);
+ Long cost = GigaGramFabAPI.COST_SINGLE_USE_TOOLS.get(type);
+ if (stats == null || cost == null) {
+ throw new IllegalArgumentException(type + " not registered");
+ }
+ long fluids = cost * GTValues.L / GTValues.M, duration = 6 * SECONDS;
+ long count = (long) (material.mDurability * stats.getMaxDurabilityMultiplier()
+ * outputModifier
+ * 100
+ / stats.getToolDamagePerContainerCraft()
+ / 10000);
+ if (count > 64 * 4) {
+ long niceFactor = findNiceFactor(fluids, count);
+ if (niceFactor < 0) {
+ double mod = (double) count / (64 * 4L);
+ fluids = Math.max((long) (fluids / mod), 1L);
+ duration = Math.max((long) (duration / mod), 1L);
+ count = 64 * 4;
+ } else {
+ fluids /= niceFactor;
+ duration = Math.max(duration / niceFactor, 1);
+ count /= niceFactor;
+ }
+ } else if (count < 128) {
+ long mod = GTUtility.ceilDiv(128, count);
+ fluids *= mod;
+ duration *= mod;
+ count *= mod;
+ }
+ GTValues.RA.stdBuilder()
+ .fluidInputs(material.getMolten(fluids)) //
+ .metadata(GGFabRecipeMaps.OUTPUT_TYPE, type) //
+ .metadata(GGFabRecipeMaps.OUTPUT_COUNT, (int) count) //
+ .eut(TierEU.RECIPE_MV)
+ .duration(duration) //
+ .addTo(GGFabRecipeMaps.toolCastRecipes);
+ }
+ }
+}
diff --git a/src/main/java/ggfab/api/GGFabRecipeMaps.java b/src/main/java/ggfab/api/GGFabRecipeMaps.java
new file mode 100644
index 0000000000..cd2663f944
--- /dev/null
+++ b/src/main/java/ggfab/api/GGFabRecipeMaps.java
@@ -0,0 +1,64 @@
+package ggfab.api;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+import net.minecraft.item.ItemStack;
+
+import com.gtnewhorizons.modularui.common.widget.ProgressBar;
+
+import ggfab.GGItemList;
+import gregtech.api.enums.ToolDictNames;
+import gregtech.api.gui.modularui.GTUITextures;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.RecipeMapBackend;
+import gregtech.api.recipe.RecipeMapBuilder;
+import gregtech.api.recipe.RecipeMetadataKey;
+import gregtech.api.recipe.metadata.SimpleRecipeMetadataKey;
+import gregtech.api.util.GTRecipe;
+
+public class GGFabRecipeMaps {
+
+ public static final RecipeMetadataKey<ToolDictNames> OUTPUT_TYPE = SimpleRecipeMetadataKey
+ .create(ToolDictNames.class, "output_type");
+ public static final RecipeMetadataKey<Integer> OUTPUT_COUNT = SimpleRecipeMetadataKey
+ .create(Integer.class, "output_count");
+ public static final RecipeMap<RecipeMapBackend> toolCastRecipes = RecipeMapBuilder.of("ggfab.recipe.toolcast")
+ .maxIO(1, 4, 1, 0)
+ .minInputs(1, 1)
+ .progressBar(GTUITextures.PROGRESSBAR_ARROW, ProgressBar.Direction.RIGHT)
+ .recipeEmitter(b -> {
+ Optional<GTRecipe> rr = b.noOptimize()
+ .validateNoInput()
+ .validateInputFluidCount(0, 1)
+ .validateNoOutput()
+ .validateNoOutputFluid()
+ .build();
+ if (!rr.isPresent()) return Collections.emptyList();
+ ToolDictNames outputType = b.getMetadata(OUTPUT_TYPE);
+ GTRecipe r = rr.get();
+ int outputSize = b.getMetadataOrDefault(OUTPUT_COUNT, 0);
+ if (outputSize > 64 * 4 || outputSize <= 0) return Collections.emptyList();
+ ItemStack shape, output;
+ try {
+ shape = GGItemList.valueOf("Shape_One_Use_" + outputType)
+ .get(0L);
+ output = GGItemList.valueOf("One_Use_" + outputType)
+ .get(outputSize);
+ } catch (IllegalArgumentException ex) {
+ // this looks like python not java, but I don't have better way around this
+ return Collections.emptyList();
+ }
+ output.stackSize = outputSize;
+ List<ItemStack> outputs = new ArrayList<>();
+ int maxStackSize = output.getMaxStackSize();
+ while (output.stackSize > maxStackSize) outputs.add(output.splitStack(maxStackSize));
+ outputs.add(output);
+ r.mInputs = new ItemStack[] { shape };
+ r.mOutputs = outputs.toArray(new ItemStack[0]);
+ return Collections.singletonList(r);
+ })
+ .build();
+}
diff --git a/src/main/java/ggfab/api/GigaGramFabAPI.java b/src/main/java/ggfab/api/GigaGramFabAPI.java
new file mode 100644
index 0000000000..3eb4862059
--- /dev/null
+++ b/src/main/java/ggfab/api/GigaGramFabAPI.java
@@ -0,0 +1,30 @@
+package ggfab.api;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import gregtech.api.enums.ToolDictNames;
+import gregtech.api.interfaces.IToolStats;
+
+public class GigaGramFabAPI {
+
+ private static final Logger apiLogger = LogManager.getLogger("GigaGramFabAPI");
+
+ private static final Map<ToolDictNames, IToolStats> SINGLE_USE_TOOLS_STORE = new HashMap<>();
+ public static final Map<ToolDictNames, IToolStats> SINGLE_USE_TOOLS = Collections
+ .unmodifiableMap(SINGLE_USE_TOOLS_STORE);
+
+ private static final Map<ToolDictNames, Long> COST_SINGLE_USE_TOOLS_STORE = new HashMap<>();
+ public static final Map<ToolDictNames, Long> COST_SINGLE_USE_TOOLS = Collections
+ .unmodifiableMap(COST_SINGLE_USE_TOOLS_STORE);
+
+ public static void addSingleUseToolType(ToolDictNames type, IToolStats stat, long materialCost) {
+ if (SINGLE_USE_TOOLS_STORE.put(type, stat) != null)
+ apiLogger.warn("Replacing stat of single use tool {}", type);
+ COST_SINGLE_USE_TOOLS_STORE.put(type, materialCost);
+ }
+}
diff --git a/src/main/java/ggfab/items/GGMetaItemDumbItems.java b/src/main/java/ggfab/items/GGMetaItemDumbItems.java
new file mode 100644
index 0000000000..479cc160ba
--- /dev/null
+++ b/src/main/java/ggfab/items/GGMetaItemDumbItems.java
@@ -0,0 +1,153 @@
+package ggfab.items;
+
+import static gregtech.api.enums.GTValues.D1;
+
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import ggfab.GGConstants;
+import gnu.trove.map.TIntObjectMap;
+import gnu.trove.map.hash.TIntObjectHashMap;
+import gregtech.api.GregTechAPI;
+import gregtech.api.enums.SubTag;
+import gregtech.api.enums.TCAspects;
+import gregtech.api.interfaces.IItemBehaviour;
+import gregtech.api.interfaces.IItemContainer;
+import gregtech.api.items.MetaBaseItem;
+import gregtech.api.objects.ItemData;
+import gregtech.api.util.GTLanguageManager;
+import gregtech.api.util.GTOreDictUnificator;
+import gregtech.api.util.GTUtility;
+
+// mostly stolen from gt5 itself.
+public class GGMetaItemDumbItems extends MetaBaseItem {
+
+ public static final int MAX_ID = 32766;
+ private final BitSet mEnabledItems = new BitSet();
+ private final BitSet mVisibleItems = new BitSet();
+ private final ArrayList<IIcon> mIconList = new ArrayList<>();
+ private final TIntObjectMap<IItemContainer> mIconOverride = new TIntObjectHashMap<>();
+
+ public GGMetaItemDumbItems(String aUnlocalized) {
+ super(aUnlocalized);
+ }
+
+ /**
+ * This adds a Custom Item to the ending Range.
+ *
+ * @param aID The Id of the assigned Item [0 - mItemAmount] (The MetaData gets auto-shifted by +mOffset)
+ * @param aEnglish The Default Localized Name of the created Item
+ * @param aToolTip The Default ToolTip of the created Item, you can also insert null for having no ToolTip
+ * @param aRandomData The OreDict Names you want to give the Item. Also used for TC Aspects and some other things.
+ * @return An ItemStack containing the newly created Item.
+ */
+ public final ItemStack addItem(int aID, String aEnglish, String aToolTip, Object... aRandomData) {
+ if (aID < 0 || aID > MAX_ID) return null;
+
+ if (aToolTip == null) aToolTip = "";
+ ItemStack rStack = new ItemStack(this, 1, aID);
+ mEnabledItems.set(aID);
+ mVisibleItems.set(aID);
+ GTLanguageManager.addStringLocalization(getUnlocalizedName(rStack) + ".name", aEnglish);
+ GTLanguageManager.addStringLocalization(getUnlocalizedName(rStack) + ".tooltip", aToolTip);
+ List<TCAspects.TC_AspectStack> tAspects = new ArrayList<>();
+ // Important Stuff to do first
+ for (Object tRandomData : aRandomData) if (tRandomData instanceof SubTag) {
+ if (tRandomData == SubTag.INVISIBLE) {
+ mVisibleItems.set(aID, false);
+ continue;
+ }
+ if (tRandomData == SubTag.NO_UNIFICATION) {
+ GTOreDictUnificator.addToBlacklist(rStack);
+ }
+ }
+ // now check for the rest
+ for (Object tRandomData : aRandomData) if (tRandomData != null) {
+ boolean tUseOreDict = true;
+ if (tRandomData instanceof IItemBehaviour) {
+ @SuppressWarnings("unchecked")
+ IItemBehaviour<MetaBaseItem> behavior = (IItemBehaviour<MetaBaseItem>) tRandomData;
+ addItemBehavior(aID, behavior);
+ tUseOreDict = false;
+ }
+ if (tRandomData instanceof IItemContainer) {
+ ((IItemContainer) tRandomData).set(rStack);
+ tUseOreDict = false;
+ }
+ if (tRandomData instanceof SubTag) {
+ continue;
+ }
+ if (tRandomData instanceof IItemContainer) {
+ mIconOverride.put(aID, (IItemContainer) tRandomData);
+ } else if (tRandomData instanceof TCAspects.TC_AspectStack) {
+ ((TCAspects.TC_AspectStack) tRandomData).addToAspectList(tAspects);
+ } else if (tRandomData instanceof ItemData) {
+ if (GTUtility.isStringValid(tRandomData)) {
+ GTOreDictUnificator.registerOre(tRandomData, rStack);
+ } else {
+ GTOreDictUnificator.addItemData(rStack, (ItemData) tRandomData);
+ }
+ } else if (tUseOreDict) {
+ GTOreDictUnificator.registerOre(tRandomData, rStack);
+ }
+ }
+ if (GregTechAPI.sThaumcraftCompat != null)
+ GregTechAPI.sThaumcraftCompat.registerThaumcraftAspectsToItem(rStack, tAspects, false);
+ return rStack;
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public final void registerIcons(IIconRegister aIconRegister) {
+ short j = (short) mEnabledItems.length();
+ mIconList.clear();
+ mIconList.ensureCapacity(j);
+ for (short i = 0; i < j; i++) {
+ if (mEnabledItems.get(i)) {
+ mIconList.add(aIconRegister.registerIcon(GGConstants.RES_PATH_ITEM + getUnlocalizedName() + "/" + i));
+ } else {
+ mIconList.add(null);
+ }
+ }
+ }
+
+ @Override
+ public IIcon getIconFromDamage(int aMetaData) {
+ if (aMetaData < 0 || aMetaData >= mIconList.size() || mIconList.get(aMetaData) == null)
+ return super.getIconFromDamage(aMetaData);
+ return mIconList.get(aMetaData);
+ }
+
+ @SuppressWarnings({ "rawtypes", "unchecked" })
+ @Override
+ @SideOnly(Side.CLIENT)
+ public void getSubItems(Item aItem, CreativeTabs aCreativeTab, List aList) {
+ int j = mEnabledItems.length();
+ for (int i = 0; i < j; i++) {
+ if (mVisibleItems.get(i) || (D1 && mEnabledItems.get(i))) {
+ ItemStack tStack = new ItemStack(this, 1, i);
+ isItemStackUsable(tStack);
+ aList.add(tStack);
+ }
+ }
+ }
+
+ @Override
+ public Long[] getElectricStats(ItemStack aStack) {
+ return null;
+ }
+
+ @Override
+ public Long[] getFluidContainerStats(ItemStack aStack) {
+ return null;
+ }
+}
diff --git a/src/main/java/ggfab/mte/MTEAdvAssLine.java b/src/main/java/ggfab/mte/MTEAdvAssLine.java
new file mode 100644
index 0000000000..a2fb0d2896
--- /dev/null
+++ b/src/main/java/ggfab/mte/MTEAdvAssLine.java
@@ -0,0 +1,1106 @@
+package ggfab.mte;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlockUnlocalizedName;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static ggfab.BlockIcons.OVERLAY_FRONT_ADV_ASSLINE;
+import static ggfab.BlockIcons.OVERLAY_FRONT_ADV_ASSLINE_ACTIVE;
+import static ggfab.BlockIcons.OVERLAY_FRONT_ADV_ASSLINE_ACTIVE_GLOW;
+import static ggfab.BlockIcons.OVERLAY_FRONT_ADV_ASSLINE_GLOW;
+import static ggfab.BlockIcons.OVERLAY_FRONT_ADV_ASSLINE_STUCK;
+import static ggfab.BlockIcons.OVERLAY_FRONT_ADV_ASSLINE_STUCK_GLOW;
+import static gregtech.GTMod.GT_FML_LOGGER;
+import static gregtech.api.enums.GTValues.V;
+import static gregtech.api.enums.HatchElement.Energy;
+import static gregtech.api.enums.HatchElement.ExoticEnergy;
+import static gregtech.api.enums.HatchElement.InputBus;
+import static gregtech.api.enums.HatchElement.InputHatch;
+import static gregtech.api.enums.HatchElement.Maintenance;
+import static gregtech.api.enums.HatchElement.OutputBus;
+import static gregtech.api.enums.Textures.BlockIcons.casingTexturePages;
+import static gregtech.api.util.GTStructureUtility.buildHatchAdder;
+import static gregtech.api.util.GTStructureUtility.ofHatchAdder;
+import static gregtech.api.util.GTUtility.filterValidMTEs;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.IntStream;
+
+import net.minecraft.client.resources.I18n;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagInt;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.StringUtils;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+import com.gtnewhorizons.modularui.api.drawable.Text;
+import com.gtnewhorizons.modularui.api.math.Alignment;
+import com.gtnewhorizons.modularui.api.widget.ISyncedWidget;
+import com.gtnewhorizons.modularui.api.widget.Widget;
+import com.gtnewhorizons.modularui.common.widget.DynamicPositionedColumn;
+import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget;
+import com.gtnewhorizons.modularui.common.widget.SlotWidget;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+
+import ggfab.ConfigurationHandler;
+import ggfab.GGConstants;
+import ggfab.mui.ClickableTextWidget;
+import ggfab.util.OverclockHelper;
+import gregtech.api.GregTechAPI;
+import gregtech.api.enums.GTValues;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.VoidingMode;
+import gregtech.api.interfaces.IHatchElement;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.MTEExtendedPowerMultiBlockBase;
+import gregtech.api.metatileentity.implementations.MTEHatch;
+import gregtech.api.metatileentity.implementations.MTEHatchDataAccess;
+import gregtech.api.metatileentity.implementations.MTEHatchInput;
+import gregtech.api.metatileentity.implementations.MTEHatchInputBus;
+import gregtech.api.metatileentity.implementations.MTEHatchMultiInput;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.RecipeMaps;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.AssemblyLineUtils;
+import gregtech.api.util.GTRecipe;
+import gregtech.api.util.GTUtility;
+import gregtech.api.util.GTWaila;
+import gregtech.api.util.IGTHatchAdder;
+import gregtech.api.util.MultiblockTooltipBuilder;
+import gregtech.api.util.OverclockCalculator;
+import gregtech.api.util.shutdown.ShutDownReason;
+import gregtech.common.tileentities.machines.MTEHatchInputBusME;
+import gregtech.common.tileentities.machines.MTEHatchInputME;
+import mcp.mobius.waila.api.IWailaConfigHandler;
+import mcp.mobius.waila.api.IWailaDataAccessor;
+
+/*
+ * Dev note: 1. This multi will be an assline but with greater throughput. it will take one input every 2.
+ */
+public class MTEAdvAssLine extends MTEExtendedPowerMultiBlockBase<MTEAdvAssLine> implements ISurvivalConstructable {
+
+ private static final ItemStack NOT_CHECKED = new ItemStack(Blocks.dirt);
+ private static final String STRUCTURE_PIECE_FIRST = "first";
+ private static final String STRUCTURE_PIECE_LATER = "later";
+ private static final String STRUCTURE_PIECE_LAST = "last";
+ public static final String TAG_KEY_CURRENT_STICK = "mCurrentStick";
+ public static final String TAG_KEY_PROGRESS_TIMES = "mProgressTimeArray";
+ private static final IStructureDefinition<MTEAdvAssLine> STRUCTURE_DEFINITION = StructureDefinition
+ .<MTEAdvAssLine>builder()
+ // @formatter:off
+ .addShape(
+ STRUCTURE_PIECE_FIRST,
+ transpose(new String[][] {
+ { " ", "e", " " },
+ { "~", "l", "G" },
+ { "g", "m", "g" },
+ { "b", "i", "b" },
+ }))
+ .addShape(
+ STRUCTURE_PIECE_LATER,
+ transpose(new String[][] {
+ { " ", "e", " " },
+ { "d", "l", "d" },
+ { "g", "m", "g" },
+ { "b", "I", "b" },
+ }))
+ .addShape(
+ STRUCTURE_PIECE_LAST,
+ transpose(new String[][] {
+ { " ", "e", " " },
+ { "d", "l", "d" },
+ { "g", "m", "g" },
+ { "o", "i", "b" },
+ }))
+ // @formatter:on
+ .addElement('G', ofBlock(GregTechAPI.sBlockCasings3, 10)) // grate machine casing
+ .addElement('l', ofBlock(GregTechAPI.sBlockCasings2, 9)) // assembler machine casing
+ .addElement('m', ofBlock(GregTechAPI.sBlockCasings2, 5)) // assembling line casing
+ .addElement(
+ 'g',
+ ofChain(
+ ofBlockUnlocalizedName("IC2", "blockAlloyGlass", 0, true),
+ ofBlockUnlocalizedName("bartworks", "BW_GlasBlocks", 0, true),
+ // warded glass
+ ofBlockUnlocalizedName("Thaumcraft", "blockCosmeticOpaque", 2, false)))
+ .addElement(
+ 'e',
+ ofChain(
+ Energy.or(ExoticEnergy)
+ .newAny(16, 1, ForgeDirection.UP, ForgeDirection.NORTH, ForgeDirection.SOUTH),
+ ofBlock(GregTechAPI.sBlockCasings2, 0)))
+ .addElement(
+ 'd',
+ buildHatchAdder(MTEAdvAssLine.class).atLeast(DataHatchElement.DataAccess)
+ .dot(2)
+ .casingIndex(42)
+ .allowOnly(ForgeDirection.NORTH)
+ .buildAndChain(GregTechAPI.sBlockCasings3, 10))
+ .addElement(
+ 'b',
+ buildHatchAdder(MTEAdvAssLine.class).atLeast(InputHatch, InputHatch, InputHatch, InputHatch, Maintenance)
+ .casingIndex(16)
+ .dot(3)
+ .allowOnly(ForgeDirection.DOWN)
+ .buildAndChain(
+ ofBlock(GregTechAPI.sBlockCasings2, 0),
+ ofHatchAdder(MTEAdvAssLine::addOutputToMachineList, 16, 4)))
+ .addElement(
+ 'I',
+ ofChain(
+ // all blocks nearby use solid steel casing, so let's use the texture of that
+ InputBus.newAny(16, 5, ForgeDirection.DOWN),
+ ofHatchAdder(MTEAdvAssLine::addOutputToMachineList, 16, 4)))
+ .addElement('i', InputBus.newAny(16, 5, ForgeDirection.DOWN))
+ .addElement('o', OutputBus.newAny(16, 4, ForgeDirection.DOWN))
+ .build();
+ private ItemStack currentStick;
+ private GTRecipe.RecipeAssemblyLine currentRecipe;
+ private final Slice[] slices = IntStream.range(0, 16)
+ .mapToObj(Slice::new)
+ .toArray(Slice[]::new);
+ private boolean processing;
+ private long inputVoltage;
+ // surely no one is using more EUt than this, no?
+ private long inputEUt;
+ private long baseEUt;
+ private boolean stuck;
+
+ private final List<MTEHatchDataAccess> mDataAccessHatches = new ArrayList<>();
+ private Map<GTUtility.ItemId, ItemStack> curBatchItemsFromME;
+ private Map<Fluid, FluidStack> curBatchFluidsFromME;
+ private int currentInputLength;
+ private String lastStopReason = "";
+ private int currentRecipeParallel = 1;
+ // Batch mode will increase parallel per slice to try to get as close as possible to this amount of ticks
+ // per slice, but will never go over this amount.
+ private static final int BATCH_MODE_DESIRED_TICKS_PER_SLICE = 128;
+
+ public MTEAdvAssLine(int aID, String aName, String aNameRegional) {
+ super(aID, aName, aNameRegional);
+ }
+
+ public MTEAdvAssLine(String aName) {
+ super(aName);
+ }
+
+ @Override
+ public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+ return new MTEAdvAssLine(mName);
+ }
+
+ public boolean addDataAccessToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) {
+ if (aTileEntity == null) return false;
+ IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+ if (aMetaTileEntity == null) return false;
+ if (aMetaTileEntity instanceof MTEHatchDataAccess) {
+ ((MTEHatch) aMetaTileEntity).updateTexture(aBaseCasingIndex);
+ return mDataAccessHatches.add((MTEHatchDataAccess) aMetaTileEntity);
+ }
+ return false;
+ }
+
+ private boolean checkMachine() {
+ return checkMachine(true) || checkMachine(false);
+ }
+
+ private boolean checkMachine(boolean leftToRight) {
+ clearHatches();
+ if (!checkPiece(STRUCTURE_PIECE_FIRST, 0, 1, 0)) return false;
+ for (int i = 1; i < 16; i++) {
+ if (!checkPiece(STRUCTURE_PIECE_LATER, leftToRight ? -i : i, 1, 0)) return false;
+ if (!mOutputBusses.isEmpty())
+ return (!mEnergyHatches.isEmpty() || !mExoticEnergyHatches.isEmpty()) && mMaintenanceHatches.size() == 1
+ && mDataAccessHatches.size() <= 1;
+ }
+ return false;
+ }
+
+ @Override
+ public void construct(ItemStack stackSize, boolean hintsOnly) {
+ buildPiece(STRUCTURE_PIECE_FIRST, stackSize, hintsOnly, 0, 1, 0);
+ int tLength = Math.min(stackSize.stackSize + 3, 16); // render 4 slices at minimal
+ for (int i = 1; i < tLength; i++) {
+ buildPiece(STRUCTURE_PIECE_LATER, stackSize, hintsOnly, -i, 1, 0);
+ }
+ }
+
+ @Override
+ public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+ if (mMachine) return -1;
+ int build = survivialBuildPiece(STRUCTURE_PIECE_FIRST, stackSize, 0, 1, 0, elementBudget, env, false, true);
+ if (build >= 0) return build;
+ int tLength = Math.min(stackSize.stackSize + 3, 16); // render 4 slices at minimal
+ for (int i = 1; i < tLength - 1; i++) {
+ build = survivialBuildPiece(STRUCTURE_PIECE_LATER, stackSize, -i, 1, 0, elementBudget, env, false, true);
+ if (build >= 0) return build;
+ }
+ return survivialBuildPiece(STRUCTURE_PIECE_LAST, stackSize, 1 - tLength, 1, 0, elementBudget, env, false, true);
+ }
+
+ @Override
+ public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing,
+ int colorIndex, boolean aActive, boolean aRedstone) {
+ if (side == facing) {
+ if (stuck) {
+ return new ITexture[] { casingTexturePages[0][16], TextureFactory.builder()
+ .addIcon(OVERLAY_FRONT_ADV_ASSLINE_STUCK)
+ .extFacing()
+ .build(),
+ TextureFactory.builder()
+ .addIcon(OVERLAY_FRONT_ADV_ASSLINE_STUCK_GLOW)
+ .extFacing()
+ .glow()
+ .build() };
+ }
+ if (aActive) return new ITexture[] { casingTexturePages[0][16], TextureFactory.builder()
+ .addIcon(OVERLAY_FRONT_ADV_ASSLINE_ACTIVE)
+ .extFacing()
+ .build(),
+ TextureFactory.builder()
+ .addIcon(OVERLAY_FRONT_ADV_ASSLINE_ACTIVE_GLOW)
+ .extFacing()
+ .glow()
+ .build() };
+ return new ITexture[] { casingTexturePages[0][16], TextureFactory.builder()
+ .addIcon(OVERLAY_FRONT_ADV_ASSLINE)
+ .extFacing()
+ .build(),
+ TextureFactory.builder()
+ .addIcon(OVERLAY_FRONT_ADV_ASSLINE_GLOW)
+ .extFacing()
+ .glow()
+ .build() };
+ }
+ return new ITexture[] { casingTexturePages[0][16] };
+ }
+
+ @Override
+ protected MultiblockTooltipBuilder createTooltip() {
+ final MultiblockTooltipBuilder tt = new MultiblockTooltipBuilder();
+ tt.addMachineType("Assembling Line")
+ .addInfo("Controller block for the Advanced Assembling Line")
+ .addInfo("Built exactly the same as standard Assembling Line")
+ .addInfo("Place in world to get more info. It will be a lengthy read.")
+ .addInfo("Assembling Line with item pipelining")
+ .addInfo("All fluids are however consumed at start")
+ .addInfo("Use voltage of worst energy hatch for overclocking")
+ .addInfo("EU/t is (number of slices working) * (overclocked EU/t)")
+ .addSeparator()
+ .beginVariableStructureBlock(5, 16, 4, 4, 3, 3, false)
+ .addStructureInfo("From Bottom to Top, Left to Right")
+ .addStructureInfo(
+ "Layer 1 - Solid Steel Machine Casing, Input Bus (last can be Output Bus), Solid Steel Machine Casing")
+ .addStructureInfo(
+ "Layer 2 - Borosilicate Glass(any)/Warded Glass/Reinforced Glass, Assembling Line Casing, Reinforced Glass")
+ .addStructureInfo("Layer 3 - Grate Machine Casing, Assembler Machine Casing, Grate Machine Casing")
+ .addStructureInfo("Layer 4 - Empty, Solid Steel Machine Casing, Empty")
+ .addStructureInfo("Up to 16 repeating slices, each one allows for 1 more item in recipes")
+ .addController("Either Grate on layer 3 of the first slice")
+ .addEnergyHatch("Any layer 4 casing", 1)
+ .addMaintenanceHatch("Any layer 1 casing", 3)
+ .addInputBus("As specified on layer 1", 4, 5)
+ .addInputHatch("Any layer 1 casing", 3)
+ .addOutputBus("Replaces Input Bus on final slice or on any solid steel casing on layer 1", 4)
+ .addOtherStructurePart("Data Access Hatch", "Optional, next to controller", 2)
+ .toolTipFinisher(GGConstants.GGMARK);
+ return tt;
+ }
+
+ private void setCurrentRecipe(ItemStack stick, GTRecipe.RecipeAssemblyLine recipe) {
+ currentRecipe = recipe;
+ currentStick = stick;
+ currentInputLength = recipe.mInputs.length;
+ }
+
+ private void clearCurrentRecipe() {
+ currentRecipe = null;
+ currentStick = null;
+ currentInputLength = -1;
+ currentRecipeParallel = 1;
+ stuck = false;
+ baseEUt = 0;
+ for (Slice slice : slices) {
+ slice.reset();
+ }
+ mMaxProgresstime = 0;
+ getBaseMetaTileEntity().issueClientUpdate();
+ }
+
+ @Override
+ public void saveNBTData(NBTTagCompound aNBT) {
+ super.saveNBTData(aNBT);
+ aNBT.setString("lastStop", lastStopReason);
+ // we need to check for active here.
+ // if machine was turned off via soft mallet it will not call checkRecipe() on recipe end
+ // in that case we don't have a current recipe, so this should be ignored
+ if (getBaseMetaTileEntity().isActive() && GTUtility.isStackValid(currentStick)) {
+ aNBT.setTag(TAG_KEY_CURRENT_STICK, currentStick.writeToNBT(new NBTTagCompound()));
+ aNBT.setInteger("mRecipeHash", currentRecipe.getPersistentHash());
+ aNBT.setIntArray(
+ TAG_KEY_PROGRESS_TIMES,
+ Arrays.stream(slices)
+ .limit(currentInputLength)
+ .mapToInt(s -> s.progress)
+ .toArray());
+ aNBT.setBoolean("stuck", stuck);
+ aNBT.setLong("inputV", inputVoltage);
+ aNBT.setLong("inputEU", inputEUt);
+ aNBT.setLong("baseEU", baseEUt);
+ aNBT.setInteger("currentParallel", currentRecipeParallel);
+ }
+ }
+
+ @Override
+ public void loadNBTData(NBTTagCompound aNBT) {
+ super.loadNBTData(aNBT);
+ lastStopReason = aNBT.getString("lastStop");
+ ItemStack loadedStack = null;
+ GTRecipe.RecipeAssemblyLine recipe = null;
+ if (aNBT.hasKey(TAG_KEY_PROGRESS_TIMES, Constants.NBT.TAG_INT_ARRAY)) {
+ int[] arr = aNBT.getIntArray(TAG_KEY_PROGRESS_TIMES);
+ for (int i = 0; i < slices.length; i++) {
+ if (i < arr.length) {
+ slices[i].progress = arr[i];
+ if (arr[i] == 0)
+ // this will be synced to client by first MTE packet to client
+ stuck = true;
+ } else slices[i].reset();
+ }
+ }
+ if (aNBT.hasKey(TAG_KEY_CURRENT_STICK, Constants.NBT.TAG_COMPOUND)) {
+ loadedStack = ItemStack.loadItemStackFromNBT(aNBT.getCompoundTag(TAG_KEY_CURRENT_STICK));
+ AssemblyLineUtils.LookupResult lookupResult = AssemblyLineUtils
+ .findAssemblyLineRecipeFromDataStick(loadedStack, false);
+ switch (lookupResult.getType()) {
+ case VALID_STACK_AND_VALID_HASH:
+ recipe = lookupResult.getRecipe();
+ stuck = aNBT.getBoolean("stuck");
+ inputVoltage = aNBT.getLong("inputV");
+ inputEUt = aNBT.getLong("inputEU");
+ baseEUt = aNBT.getLong("baseEU");
+ currentRecipeParallel = aNBT.getInteger("currentParallel");
+ if (inputVoltage <= 0 || inputEUt <= 0 || baseEUt >= 0) {
+ criticalStopMachine("ggfab.gui.advassline.shutdown.load.energy");
+ loadedStack = null;
+ recipe = null;
+ }
+ break;
+ case VALID_STACK_AND_VALID_RECIPE:
+ // recipe is there, but it has been changed. to prevent issues, abort the current recipe
+ // TODO finish the last recipe instead of aborting
+ default:
+ // recipe is gone. to prevent issues, abort the current recipe
+ criticalStopMachine("ggfab.gui.advassline.shutdown.load.recipe");
+ loadedStack = null;
+ break;
+ }
+ }
+ if (loadedStack == null || recipe == null) clearCurrentRecipe();
+ else setCurrentRecipe(loadedStack, recipe);
+ }
+
+ /**
+ * roughly the same as {@link #criticalStopMachine()}, but does not attempt to send a halting sound if world is not
+ * loaded. also supports setting a stop reason
+ */
+ private void criticalStopMachine(String reason) {
+ int oMaxProgresstime = mMaxProgresstime;
+ stopMachine();
+ // don't do these at all if the machine wasn't working before anyway
+ if (oMaxProgresstime > 0) {
+ if (getBaseMetaTileEntity().getWorld() != null) sendSound(INTERRUPT_SOUND_INDEX);
+ getBaseMetaTileEntity().setShutdownStatus(true);
+ lastStopReason = reason;
+ }
+ }
+
+ @Override
+ public IStructureDefinition<MTEAdvAssLine> getStructureDefinition() {
+ return STRUCTURE_DEFINITION;
+ }
+
+ @Override
+ public void clearHatches() {
+ super.clearHatches();
+ mExoticEnergyHatches.clear();
+ mDataAccessHatches.clear();
+ }
+
+ @Override
+ public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+ if (checkMachine() && (mEnergyHatches.size() > 0 || mExoticEnergyHatches.size() > 0)) {
+ long oV = inputVoltage, oEut = inputEUt;
+ inputVoltage = Integer.MAX_VALUE;
+ inputEUt = 0;
+ mEnergyHatches.forEach(this::recordEnergySupplier);
+ mExoticEnergyHatches.forEach(this::recordEnergySupplier);
+ if (mMaxProgresstime > 0 && (oV != inputVoltage || oEut != inputEUt)) {
+ criticalStopMachine("ggfab.gui.advassline.shutdown.structure");
+ }
+ return true;
+ } else {
+ inputVoltage = V[0];
+ return false;
+ }
+ }
+
+ private void recordEnergySupplier(MTEHatch hatch) {
+ if (!hatch.isValid()) return;
+ inputEUt += hatch.maxEUInput() * hatch.maxWorkingAmperesIn();
+ inputVoltage = Math.min(inputVoltage, hatch.maxEUInput());
+ if (inputEUt < 0) inputEUt = Long.MAX_VALUE;
+ }
+
+ @Override
+ protected void startRecipeProcessing() {
+ if (!processing) {
+ super.startRecipeProcessing();
+ curBatchItemsFromME = getStoredInputsFromME();
+ curBatchFluidsFromME = getStoredFluidsFromME();
+ processing = true;
+ }
+ }
+
+ @Override
+ protected void endRecipeProcessing() {
+ if (!processing) return;
+ super.endRecipeProcessing();
+ processing = false;
+ }
+
+ @Override
+ public void onValueUpdate(byte aValue) {
+ boolean oStuck = stuck;
+ stuck = (aValue & 1) == 1;
+ if (oStuck != stuck) getBaseMetaTileEntity().issueTextureUpdate();
+ }
+
+ @Override
+ public byte getUpdateData() {
+ return (byte) (stuck ? 1 : 0);
+ }
+
+ @Override
+ protected void drawTexts(DynamicPositionedColumn screenElements, SlotWidget inventorySlot) {
+ super.drawTexts(screenElements, inventorySlot);
+ /*
+ * SliceStatusWidget[] arr =
+ * Arrays.stream(slices).map(SliceStatusWidget::new).toArray(SliceStatusWidget[]::new);
+ * screenElements.widgets(arr); screenElements.widget(new FakeSyncWidget.IntegerSyncer(() -> currentInputLength,
+ * l -> { currentInputLength = l; for (SliceStatusWidget w : arr) { w.updateText(); } }));
+ */
+ screenElements.widget(
+ new TextWidget(Text.localised("ggfab.gui.advassline.shutdown")).setEnabled(this::hasAbnormalStopReason));
+ screenElements.widget(
+ new TextWidget().setTextSupplier(() -> Text.localised(lastStopReason))
+ .attachSyncer(
+ new FakeSyncWidget.StringSyncer(() -> lastStopReason, r -> this.lastStopReason = r),
+ screenElements)
+ .setEnabled(this::hasAbnormalStopReason));
+ screenElements.widget(
+ new ClickableTextWidget(
+ Text.localised("ggfab.gui.advassline.shutdown_clear")
+ .alignment(Alignment.CenterLeft)).setMarginInLines(0)
+ .setOnClick((d, w) -> lastStopReason = "")
+ .setSize(36, 20)
+ .setEnabled(this::hasAbnormalStopReason));
+ }
+
+ private Boolean hasAbnormalStopReason(Widget w) {
+ return !StringUtils.isNullOrEmpty(lastStopReason);
+ }
+
+ @Override
+ public RecipeMap<?> getRecipeMap() {
+ return RecipeMaps.assemblylineVisualRecipes;
+ }
+
+ @Override
+ public boolean onRunningTick(ItemStack aStack) {
+ if (currentRecipe == null) {
+ criticalStopMachine("ggfab.gui.advassline.shutdown.recipe_null");
+ return false;
+ }
+ for (MTEHatchDataAccess hatch_dataAccess : mDataAccessHatches) {
+ hatch_dataAccess.setActive(true);
+ }
+
+ if (mInputBusses.size() < currentInputLength) {
+ criticalStopMachine("ggfab.gui.advassline.shutdown.input_busses");
+ return false;
+ }
+ boolean oStuck = stuck;
+ stuck = false;
+
+ for (int i = slices.length - 1; i >= 0; i--) {
+ slices[i].tick();
+ }
+
+ if (oStuck != stuck)
+ // send the status as it has changed
+ getBaseMetaTileEntity().issueClientUpdate();
+
+ if (getBaseMetaTileEntity().isAllowedToWork() && slices[0].progress < 0) {
+ startRecipeProcessing();
+ if (hasAllItems(currentRecipe, this.currentRecipeParallel)
+ && hasAllFluids(currentRecipe, this.currentRecipeParallel)
+ && slices[0].start()) {
+ drainAllFluids(currentRecipe, this.currentRecipeParallel);
+ mProgresstime = 0;
+ }
+ }
+
+ boolean foundWorking = false;
+ int working = 0;
+ for (Slice slice : slices) {
+ if (slice.progress >= 0) {
+ if (!foundWorking) {
+ foundWorking = true;
+ mProgresstime = (slice.id + 1) * (mMaxProgresstime / currentInputLength) - slice.progress;
+ }
+ }
+ if (slice.progress > 0) working++;
+ }
+ lEUt = working * baseEUt;
+
+ if (lEUt > 0) {
+ // overflow again :(
+ lEUt = Long.MIN_VALUE;
+ for (int i = 0; i < working; i++) {
+ if (!drainEnergyInput(-baseEUt)) {
+ criticalStopMachine("ggfab.gui.advassline.shutdown.energy");
+ return false;
+ }
+ }
+ } else {
+ if (!super.onRunningTick(aStack)) return false;
+ }
+
+ endRecipeProcessing();
+ return true;
+ }
+
+ private ItemStack getInputBusContent(int index) {
+ if (index < 0 || index >= mInputBusses.size()) return null;
+ MTEHatchInputBus inputBus = mInputBusses.get(index);
+ if (!inputBus.isValid()) return null;
+ if (inputBus instanceof MTEHatchInputBusME meBus) {
+ ItemStack item = meBus.getShadowItemStack(0);
+ if (item == null) return null;
+ GTUtility.ItemId id = GTUtility.ItemId.createNoCopy(item);
+ if (!curBatchItemsFromME.containsKey(id)) return null;
+ return curBatchItemsFromME.get(id);
+ }
+ return inputBus.getStackInSlot(0);
+
+ }
+
+ private FluidStack getInputHatchContent(int index) {
+ if (index < 0 || index >= mInputHatches.size()) return null;
+ MTEHatchInput inputHatch = mInputHatches.get(index);
+ if (!inputHatch.isValid()) return null;
+ if (inputHatch instanceof MTEHatchInputME meHatch) {
+ FluidStack fluid = meHatch.getShadowFluidStack(0);
+ if (fluid == null) return null;
+ if (!curBatchFluidsFromME.containsKey(fluid.getFluid())) return null;
+ return curBatchFluidsFromME.get(fluid.getFluid());
+ }
+ if (inputHatch instanceof MTEHatchMultiInput multiHatch) {
+ return multiHatch.getFluid(0);
+ }
+ return inputHatch.getFillableStack();
+ }
+
+ private GTRecipe.RecipeAssemblyLine findRecipe(ItemStack tDataStick) {
+ AssemblyLineUtils.LookupResult tLookupResult = AssemblyLineUtils
+ .findAssemblyLineRecipeFromDataStick(tDataStick, false);
+
+ if (tLookupResult.getType() == AssemblyLineUtils.LookupResultType.INVALID_STICK) return null;
+
+ GTRecipe.RecipeAssemblyLine tRecipe = tLookupResult.getRecipe();
+ // Check if the recipe on the data stick is the current recipe for it's given output, if not we update it
+ // and continue to next.
+ if (tLookupResult.getType() != AssemblyLineUtils.LookupResultType.VALID_STACK_AND_VALID_HASH) {
+ tRecipe = AssemblyLineUtils.processDataStick(tDataStick);
+ if (tRecipe == null) {
+ return null;
+ }
+ }
+
+ // So here we check against the recipe found on the data stick.
+ // If we run into missing buses/hatches or bad inputs, we go to the next data stick.
+ // This check only happens if we have a valid up-to-date data stick.
+
+ // Check item Inputs align. For this we do not need to consider batch mode parallels yet, this will be done
+ // later on during recipe start.
+ if (!hasAllItems(tRecipe, 1)) return null;
+
+ // Check Fluid Inputs align. Again, do not consider parallels
+ if (!hasAllFluids(tRecipe, 1)) return null;
+
+ if (GTValues.D1) {
+ GT_FML_LOGGER.info("Check overclock");
+ }
+ if (GTValues.D1) {
+ GT_FML_LOGGER.info("Find available recipe");
+ }
+ return tRecipe;
+ }
+
+ private boolean hasAllItems(GTRecipe.RecipeAssemblyLine tRecipe, int parallel) {
+ int aItemCount = tRecipe.mInputs.length;
+ if (mInputBusses.size() < aItemCount) return false;
+ int[] itemConsumptions = GTRecipe.RecipeAssemblyLine.getItemConsumptionAmountArray(mInputBusses, tRecipe);
+ if (itemConsumptions == null || itemConsumptions.length == 0) {
+ return false;
+ }
+ int maxParallel = (int) GTRecipe.RecipeAssemblyLine
+ .maxParallelCalculatedByInputItems(mInputBusses, parallel, itemConsumptions, curBatchItemsFromME);
+ return maxParallel >= parallel;
+ }
+
+ private boolean hasAllFluids(GTRecipe.RecipeAssemblyLine tRecipe, int parallel) {
+ int aFluidCount = tRecipe.mFluidInputs.length;
+ if (mInputHatches.size() < aFluidCount) return false;
+ int maxParallel = (int) GTRecipe.RecipeAssemblyLine
+ .maxParallelCalculatedByInputFluids(mInputHatches, parallel, tRecipe.mFluidInputs, curBatchFluidsFromME);
+ return maxParallel >= parallel;
+ }
+
+ /**
+ * @param state using bitmask, 1 for IntegratedCircuit, 2 for DataStick, 4 for DataOrb
+ */
+ private boolean isCorrectDataItem(ItemStack aStack, int state) {
+ if ((state & 1) != 0 && ItemList.Circuit_Integrated.isStackEqual(aStack, true, true)) return true;
+ if ((state & 2) != 0 && ItemList.Tool_DataStick.isStackEqual(aStack, false, true)) return true;
+ return (state & 4) != 0 && ItemList.Tool_DataOrb.isStackEqual(aStack, false, true);
+ }
+
+ /**
+ * @param state using bitmask, 1 for IntegratedCircuit, 2 for DataStick, 4 for DataOrb
+ */
+ public ArrayList<ItemStack> getDataItems(int state) {
+ ArrayList<ItemStack> rList = new ArrayList<>();
+ if (GTUtility.isStackValid(mInventory[1]) && isCorrectDataItem(mInventory[1], state)) {
+ rList.add(mInventory[1]);
+ }
+ for (MTEHatchDataAccess tHatch : mDataAccessHatches) {
+ if (tHatch.isValid()) {
+ for (int i = 0; i < tHatch.getBaseMetaTileEntity()
+ .getSizeInventory(); i++) {
+ if (tHatch.getBaseMetaTileEntity()
+ .getStackInSlot(i) != null && isCorrectDataItem(
+ tHatch.getBaseMetaTileEntity()
+ .getStackInSlot(i),
+ state))
+ rList.add(
+ tHatch.getBaseMetaTileEntity()
+ .getStackInSlot(i));
+ }
+ }
+ }
+ return rList;
+ }
+
+ // this is only called when all slices have finished their work
+ // and the first slice cannot find a input/fluid cannot be found
+ // so we are safe to assume the old recipe no longer works
+ @Override
+ @NotNull
+ public CheckRecipeResult checkProcessing() {
+ if (GTValues.D1) {
+ GT_FML_LOGGER.info("Start Adv ALine recipe check");
+ }
+ clearCurrentRecipe();
+ CheckRecipeResult result = CheckRecipeResultRegistry.NO_DATA_STICKS;
+ ArrayList<ItemStack> tDataStickList = getDataItems(2);
+ if (tDataStickList.isEmpty()) {
+ return result;
+ }
+ if (GTValues.D1) {
+ GT_FML_LOGGER.info("Stick accepted, " + tDataStickList.size() + " Data Sticks found");
+ }
+
+ GTRecipe.RecipeAssemblyLine recipe = null;
+
+ for (ItemStack stack : tDataStickList) {
+ recipe = findRecipe(stack);
+ if (recipe == null) {
+ result = CheckRecipeResultRegistry.NO_RECIPE;
+ continue;
+ }
+ if (recipe.mEUt > inputVoltage) {
+ result = CheckRecipeResultRegistry.insufficientPower(recipe.mEUt);
+ continue;
+ }
+
+ setCurrentRecipe(stack, recipe);
+ // first overclock normally
+ // we use the new oc calculator instead
+ // calculateOverclockedNessMulti from super class has a mysterious 5% cable loss thing at the moment
+ // of writing
+ OverclockCalculator ocCalc = new OverclockCalculator().setRecipeEUt(currentRecipe.mEUt)
+ .setDuration(Math.max(recipe.mDuration / recipe.mInputs.length, 1))
+ .setEUt(inputVoltage)
+ .calculate();
+ // since we already checked mEUt <= inputVoltage, no need to check if recipe is too OP
+ lEUt = ocCalc.getConsumption();
+ mMaxProgresstime = ocCalc.getDuration();
+ // then laser overclock if needed
+ if (!mExoticEnergyHatches.isEmpty()) {
+ OverclockHelper.OverclockOutput laserOverclock = OverclockHelper.laserOverclock(
+ lEUt,
+ mMaxProgresstime,
+ inputEUt / recipe.mInputs.length,
+ ConfigurationHandler.INSTANCE.getLaserOCPenaltyFactor());
+ if (laserOverclock != null) {
+ lEUt = laserOverclock.getEUt();
+ mMaxProgresstime = laserOverclock.getDuration();
+ }
+ }
+ // Save this for batch mode parallel calculations
+ int timePerSlice = mMaxProgresstime;
+ // correct the recipe duration
+ mMaxProgresstime *= recipe.mInputs.length;
+
+ // Finally apply batch mode parallels if possible.
+ // For this we need to verify the first item slot and all fluids slots have enough resources
+ // to execute parallels.
+ // Note that we skip this entirely if the time for each slice is more than
+ // BATCH_MODE_DESIRED_TICKS_PER_SLICE ticks, since in this case the amount of batches will always be 1
+ if (super.isBatchModeEnabled() && timePerSlice < BATCH_MODE_DESIRED_TICKS_PER_SLICE) {
+ // Calculate parallel based on time per slice, and the amount of fluid in the first fluid slot.
+ // We use fluid, since this way players can limit parallel by controlling how much fluid
+ // ends up in each AAL. This way, batch mode will not slow down setups where multiple AAL
+ // are connected to the same set of input items. Note that this will still suffer from the same
+ // issue if using stocking hatch, but in this case increasing pattern size can help.
+
+ // Note that every assline recipe has a fluid ingredient.
+ FluidStack firstFluidSlot = getInputHatchContent(0);
+ if (firstFluidSlot == null) {
+ result = CheckRecipeResultRegistry.INTERNAL_ERROR;
+ break;
+ }
+ int recipesAvailable = Math.floorDiv(firstFluidSlot.amount, recipe.mFluidInputs[0].amount);
+ // Divide recipes available by the amount of slices in the recipe. This will prevent the AAL from
+ // batching instead of parallelizing, which would make it effectively slower.
+ recipesAvailable = Math.floorDiv(recipesAvailable, recipe.mInputs.length);
+ // Sanity check to avoid this being zero when there is only one recipe available.
+ recipesAvailable = Math.max(recipesAvailable, 1);
+ int desiredBatches = Math.floorDiv(BATCH_MODE_DESIRED_TICKS_PER_SLICE, timePerSlice);
+ // Limit the amount of parallel to both the amount of recipes available and the maximum number
+ // of batches we want to run. The latter is done to prevent batch mode from ever going above
+ // BATCH_MODE_DESIRED_TICKS_PER_SLICE ticks per slice (see also where it is defined above).
+ int parallel = Math.min(recipesAvailable, desiredBatches);
+ if (hasAllFluids(recipe, parallel) && hasAllItems(recipe, parallel)) {
+ this.currentRecipeParallel = parallel;
+ // Update recipe duration with final batch mode multiplier
+ mMaxProgresstime *= this.currentRecipeParallel;
+ }
+ }
+ result = CheckRecipeResultRegistry.SUCCESSFUL;
+ break;
+ }
+ if (!result.wasSuccessful()) {
+ clearCurrentRecipe();
+ return result;
+ }
+ if (recipe == null || !slices[0].start() || currentRecipeParallel <= 0) {
+ clearCurrentRecipe();
+ // something very very wrong...
+ return CheckRecipeResultRegistry.INTERNAL_ERROR;
+ }
+
+ if (GTValues.D1) {
+ GT_FML_LOGGER.info("All checked start consuming inputs");
+ }
+ drainAllFluids(recipe, this.currentRecipeParallel);
+
+ // Apply parallel
+ mOutputItems = new ItemStack[] { recipe.mOutput.copy() };
+ mOutputItems[0].stackSize *= this.currentRecipeParallel;
+
+ if (this.lEUt > 0) {
+ this.lEUt = -this.lEUt;
+ }
+ baseEUt = lEUt;
+ this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
+ this.mEfficiencyIncrease = 10000;
+
+ if (GTValues.D1) {
+ GT_FML_LOGGER.info("Recipe successful");
+ }
+ return CheckRecipeResultRegistry.SUCCESSFUL;
+ }
+
+ @Override
+ public boolean supportsVoidProtection() {
+ return true;
+ }
+
+ @Override
+ public Set<VoidingMode> getAllowedVoidingModes() {
+ return VoidingMode.ITEM_ONLY_MODES;
+ }
+
+ @Override
+ public boolean isCorrectMachinePart(ItemStack aStack) {
+ return true;
+ }
+
+ @Override
+ public int getMaxEfficiency(ItemStack aStack) {
+ return 10000;
+ }
+
+ @Override
+ public int getDamageToComponent(ItemStack aStack) {
+ return 0;
+ }
+
+ @Override
+ public boolean explodesOnComponentBreak(ItemStack aStack) {
+ return false;
+ }
+
+ @Override
+ protected boolean supportsSlotAutomation(int aSlot) {
+ return aSlot == getControllerSlotIndex();
+ }
+
+ @Override
+ public void getWailaBody(ItemStack itemStack, List<String> currentTip, IWailaDataAccessor accessor,
+ IWailaConfigHandler config) {
+ super.getWailaBody(itemStack, currentTip, accessor, config);
+ NBTTagCompound tag = accessor.getNBTData();
+ String machineProgressString = GTWaila.getMachineProgressString(
+ tag.getBoolean("isActive"),
+ tag.getInteger("maxProgress"),
+ tag.getInteger("progress"));
+ currentTip.remove(machineProgressString);
+
+ int duration = tag.getInteger("mDuration");
+ if (tag.hasKey(TAG_KEY_PROGRESS_TIMES, Constants.NBT.TAG_LIST)) {
+ NBTTagList tl = tag.getTagList(TAG_KEY_PROGRESS_TIMES, Constants.NBT.TAG_INT);
+ @SuppressWarnings("unchecked")
+ List<NBTTagInt> list = tl.tagList;
+ for (int i = 0, listSize = list.size(); i < listSize; i++) {
+ NBTTagInt t = list.get(i);
+ int progress = t.func_150287_d();
+ if (progress == 0) {
+ currentTip.add(I18n.format("ggfab.waila.advassline.slice.stuck", i + 1));
+ } else if (progress < 0) {
+ currentTip.add(I18n.format("ggfab.waila.advassline.slice.idle", i + 1));
+ } else if (duration > 40) {
+ currentTip.add(
+ I18n.format("ggfab.waila.advassline.slice", i + 1, (duration - progress) / 20, duration / 20));
+ } else {
+ currentTip
+ .add(I18n.format("ggfab.waila.advassline.slice.small", i + 1, duration - progress, duration));
+ }
+ }
+ }
+ }
+
+ @Override
+ public void getWailaNBTData(EntityPlayerMP player, TileEntity tile, NBTTagCompound tag, World world, int x, int y,
+ int z) {
+ super.getWailaNBTData(player, tile, tag, world, x, y, z);
+ if (currentRecipe == null || !getBaseMetaTileEntity().isActive()) return;
+ NBTTagList l = new NBTTagList();
+ for (int i = 0; i < currentInputLength; i++) {
+ l.appendTag(new NBTTagInt(slices[i].progress));
+ }
+ tag.setTag(TAG_KEY_PROGRESS_TIMES, l);
+ tag.setInteger("mDuration", mMaxProgresstime / currentInputLength);
+ }
+
+ /**
+ * Caller is responsible to check and ensure the hatches are there and has all the fluid needed. You will usually
+ * want to ensure hasAllFluid was called right before calling this, otherwise very bad things can happen.
+ */
+ private void drainAllFluids(GTRecipe.RecipeAssemblyLine recipe, int parallel) {
+ GTRecipe.RecipeAssemblyLine
+ .consumeInputFluids(mInputHatches, parallel, recipe.mFluidInputs, curBatchFluidsFromME);
+ for (MTEHatchInput tHatch : filterValidMTEs(mInputHatches)) tHatch.updateSlots();
+ }
+
+ @Override
+ public void stopMachine(@NotNull ShutDownReason reason) {
+ clearCurrentRecipe();
+ super.stopMachine(reason);
+ }
+
+ @Override
+ public boolean supportsBatchMode() {
+ return true;
+ }
+
+ @Override
+ public boolean onWireCutterRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer,
+ float aX, float aY, float aZ) {
+ if (aPlayer.isSneaking()) {
+ batchMode = !batchMode;
+ if (batchMode) {
+ GTUtility.sendChatToPlayer(aPlayer, "Batch mode enabled");
+ } else {
+ GTUtility.sendChatToPlayer(aPlayer, "Batch mode disabled");
+ }
+ }
+ return true;
+ }
+
+ private class SliceStatusWidget extends TextWidget implements ISyncedWidget {
+
+ private final Slice slice;
+ private int lastProgress = -2;
+ private Text text;
+
+ private SliceStatusWidget(Slice slice) {
+ this.slice = slice;
+ updateText();
+ setEnabled(w -> slice.progress == 0 && currentInputLength > slice.id);
+ }
+
+ @Override
+ public Text getText() {
+ return text;
+ }
+
+ @Override
+ public void readOnClient(int id, PacketBuffer buf) {
+ if (id == 0) {
+ slice.progress = buf.readVarIntFromBuffer();
+ updateText();
+ checkNeedsRebuild();
+ }
+ }
+
+ public void updateText() {
+ String type = "unknown";
+ if (slice.progress == 0) type = "stuck";
+ else if (slice.progress < 0) type = "idle";
+ text = Text.localised("ggfab.gui.advassline.slice." + type, slice.id);
+ }
+
+ @Override
+ public void readOnServer(int id, PacketBuffer buf) {}
+
+ @Override
+ public void detectAndSendChanges(boolean init) {
+ if (slice.progress != lastProgress) {
+ // suppress small normal progress update
+ if (slice.progress > 0 && lastProgress > 0 && lastProgress - slice.progress < 10) return;
+ lastProgress = slice.progress;
+ syncToClient(0, b -> b.writeVarIntToBuffer(slice.progress));
+ }
+ }
+
+ @Override
+ public void markForUpdate() {}
+
+ @Override
+ public void unMarkForUpdate() {}
+
+ @Override
+ public boolean isMarkedForUpdate() {
+ return false;
+ }
+ }
+
+ private class Slice {
+
+ private final int id;
+ private int progress = -1;
+
+ public Slice(int id) {
+ this.id = id;
+ }
+
+ public void reset() {
+ progress = -1;
+ }
+
+ public void tick() {
+ if (progress < 0) return;
+ if (progress == 0 || --progress == 0) {
+ // id==0 will be end of chain if 1 input, so we need a +1 here
+ if (id + 1 >= currentInputLength) {
+ // use previously calculated parallel output
+ ItemStack output = mOutputItems[0];
+ if (addOutput(output) || !voidingMode.protectItem) reset();
+ else stuck = true;
+ } else {
+ if (slices[id + 1].start()) reset();
+ else stuck = true;
+ }
+ }
+ }
+
+ public boolean start() {
+ if (progress >= 0) return false;
+ startRecipeProcessing();
+ ItemStack stack = getInputBusContent(id);
+ if (stack == null) return false;
+ int size = GTRecipe.RecipeAssemblyLine
+ .getMatchedIngredientAmount(stack, currentRecipe.mInputs[id], currentRecipe.mOreDictAlt[id]);
+ if (size < 0 || stack.stackSize < size * currentRecipeParallel) return false;
+ progress = mMaxProgresstime / currentInputLength;
+ stack.stackSize -= size * currentRecipeParallel;
+ mInputBusses.get(id)
+ .updateSlots();
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ return "Slice{" + "id=" + id + ", progress=" + progress + '}';
+ }
+ }
+
+ private enum DataHatchElement implements IHatchElement<MTEAdvAssLine> {
+
+ DataAccess;
+
+ @Override
+ public List<? extends Class<? extends IMetaTileEntity>> mteClasses() {
+ return Collections.singletonList(MTEHatchDataAccess.class);
+ }
+
+ @Override
+ public IGTHatchAdder<MTEAdvAssLine> adder() {
+ return MTEAdvAssLine::addDataAccessToMachineList;
+ }
+
+ @Override
+ public long count(MTEAdvAssLine t) {
+ return t.mDataAccessHatches.size();
+ }
+ }
+}
diff --git a/src/main/java/ggfab/mte/MTELinkedInputBus.java b/src/main/java/ggfab/mte/MTELinkedInputBus.java
new file mode 100644
index 0000000000..0e84c4967d
--- /dev/null
+++ b/src/main/java/ggfab/mte/MTELinkedInputBus.java
@@ -0,0 +1,683 @@
+package ggfab.mte;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.UUID;
+
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ChatComponentTranslation;
+import net.minecraft.util.StatCollector;
+import net.minecraft.world.WorldSavedData;
+import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import com.gtnewhorizons.modularui.api.drawable.Text;
+import com.gtnewhorizons.modularui.api.forge.ItemStackHandler;
+import com.gtnewhorizons.modularui.api.math.Alignment;
+import com.gtnewhorizons.modularui.api.math.Color;
+import com.gtnewhorizons.modularui.api.screen.ModularWindow;
+import com.gtnewhorizons.modularui.api.screen.UIBuildContext;
+import com.gtnewhorizons.modularui.common.internal.wrapper.BaseSlot;
+import com.gtnewhorizons.modularui.common.widget.CycleButtonWidget;
+import com.gtnewhorizons.modularui.common.widget.SlotGroup;
+import com.gtnewhorizons.modularui.common.widget.TextWidget;
+import com.gtnewhorizons.modularui.common.widget.textfield.TextFieldWidget;
+
+import ggfab.GGConstants;
+import gregtech.api.enums.ItemList;
+import gregtech.api.gui.modularui.GTUITextures;
+import gregtech.api.interfaces.IDataCopyable;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.MTEHatchInputBus;
+import gregtech.api.metatileentity.implementations.MTEMultiBlockBase;
+import gregtech.api.recipe.check.CheckRecipeResult;
+import gregtech.api.recipe.check.CheckRecipeResultRegistry;
+import gregtech.api.util.GTOreDictUnificator;
+import gregtech.api.util.GTUtility;
+import gregtech.common.tileentities.machines.IRecipeProcessingAwareHatch;
+
+public class MTELinkedInputBus extends MTEHatchInputBus implements IRecipeProcessingAwareHatch, IDataCopyable {
+
+ public static final int SIZE_INVENTORY = 18;
+ public static final String COPIED_DATA_IDENTIFIER = "linkedinputbus";
+ private SharedInventory mRealInventory;
+ private final ItemStackHandlerProxy handler = new ItemStackHandlerProxy();
+ private String mChannel;
+ private boolean mPrivate;
+ private State mState;
+ private WorldSave save;
+
+ public MTELinkedInputBus(int id, String name, String nameRegional, int tier) {
+ super(
+ id,
+ name,
+ nameRegional,
+ tier,
+ 1,
+ new String[] { SIZE_INVENTORY + " slot input bus linked together wirelessly",
+ "Link does not cross world boundary", "Left/right click with data stick to copy/paste configuration",
+ GGConstants.GGMARK_TOOLTIP, });
+ }
+
+ public MTELinkedInputBus(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+ super(aName, aTier, 1, aDescription, aTextures);
+ }
+
+ @Override
+ public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+ return new MTELinkedInputBus(mName, mTier, mDescriptionArray, mTextures);
+ }
+
+ @Override
+ public int getCircuitSlot() {
+ return 0;
+ }
+
+ @Override
+ public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) {
+ builder.widget(
+ new TextFieldWidget().setSynced(true, true)
+ .setGetter(() -> mChannel == null ? "" : mChannel)
+ .setSetter(this::setChannel)
+ .setTextColor(Color.WHITE.dark(1))
+ .setTextAlignment(Alignment.CenterLeft)
+ .setBackground(GTUITextures.BACKGROUND_TEXT_FIELD)
+ .setGTTooltip(() -> mTooltipCache.getData("ggfab.tooltip.linked_input_bus.change_freq_warn"))
+ .setSize(60, 18)
+ .setPos(48, 3))
+ .widget(
+ new CycleButtonWidget().setToggle(this::isPrivate, this::setPrivate)
+ .setTextureGetter(
+ i -> i == 1 ? GTUITextures.OVERLAY_BUTTON_CHECKMARK : GTUITextures.OVERLAY_BUTTON_CROSS)
+ .setVariableBackground(GTUITextures.BUTTON_STANDARD_TOGGLE)
+ .setSynced(true, true)
+ .setGTTooltip(() -> mTooltipCache.getData("ggfab.tooltip.linked_input_bus.private"))
+ .setSize(18, 18)
+ .setPos(150, 3))
+ .widget(
+ SlotGroup.ofItemHandler(handler, 9)
+ .startFromSlot(0)
+ .endAtSlot(SIZE_INVENTORY - 1)
+ .background(getGUITextureSet().getItemSlot())
+ .slotCreator(i -> new BaseSlot(handler, i, false) {
+
+ @Override
+ public ItemStack getStack() {
+ return isEnabled() ? super.getStack() : null;
+ }
+
+ @Override
+ public boolean isEnabled() {
+ return mChannel != null;
+ }
+ })
+ .build()
+ .setPos(7, 24))
+ .widget(
+ new TextWidget(new Text("Private")).setPos(110, 3)
+ .setSize(43, 20))
+ .widget(
+ new TextWidget(new Text("Channel")).setPos(5, 3)
+ .setSize(43, 20));
+ }
+
+ @Override
+ public int getCircuitSlotX() {
+ return 152;
+ }
+
+ @Override
+ public ItemStack getStackInSlot(int aIndex) {
+ if (aIndex == getCircuitSlot()) return super.getStackInSlot(aIndex);
+ if (mState != State.Blocked && mChannel != null && mRealInventory != null) {
+ if (aIndex > 0 && aIndex <= SIZE_INVENTORY) return mRealInventory.stacks[aIndex - 1];
+ }
+ return null;
+ }
+
+ @Override
+ public void setInventorySlotContents(int aIndex, ItemStack aStack) {
+ if (aIndex == getCircuitSlot()) {
+ mInventory[0] = GTUtility.copyAmount(0, aStack);
+ markDirty();
+ } else if (mState != State.Blocked && mChannel != null && mRealInventory != null) {
+ if (aIndex > 0 && aIndex <= SIZE_INVENTORY) {
+ mRealInventory.stacks[aIndex - 1] = aStack;
+ getWorldSave().markDirty();
+ }
+ }
+ }
+
+ @Override
+ public ITexture[] getTexturesActive(ITexture aBaseTexture) {
+ return super.getTexturesActive(aBaseTexture);
+ }
+
+ @Override
+ public ITexture[] getTexturesInactive(ITexture aBaseTexture) {
+ return super.getTexturesInactive(aBaseTexture);
+ }
+
+ @Override
+ public boolean canInsertItem(int aIndex, ItemStack aStack, int ordinalSide) {
+ return isValidSlot(aIndex) && aStack != null
+ && mChannel != null
+ && mRealInventory != null
+ && aIndex > getCircuitSlot()
+ && aIndex < SIZE_INVENTORY + 1
+ && (mRealInventory.stacks[aIndex - 1] == null
+ || GTUtility.areStacksEqual(aStack, mRealInventory.stacks[aIndex - 1]))
+ && allowPutStack(getBaseMetaTileEntity(), aIndex, ForgeDirection.getOrientation(ordinalSide), aStack);
+ }
+
+ @Override
+ public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side,
+ ItemStack aStack) {
+ return side == getBaseMetaTileEntity().getFrontFacing() && aIndex != getCircuitSlot()
+ && (mRecipeMap == null || disableFilter || mRecipeMap.containsInput(aStack))
+ && (mRealInventory.disableLimited || limitedAllowPutStack(aIndex, aStack));
+ }
+
+ @Override
+ protected boolean limitedAllowPutStack(int aIndex, ItemStack aStack) {
+ for (int i = 0; i < SIZE_INVENTORY; i++)
+ if (GTUtility.areStacksEqual(GTOreDictUnificator.get_nocopy(aStack), mRealInventory.stacks[i]))
+ return i == aIndex - 1;
+ return mRealInventory.stacks[aIndex - 1] == null;
+ }
+
+ @Override
+ public boolean canExtractItem(int aIndex, ItemStack aStack, int aSide) {
+ return false;
+ }
+
+ @Override
+ public int getSizeInventory() {
+ if (mState != State.Blocked && mChannel != null && mRealInventory != null) return SIZE_INVENTORY + 1;
+ return 1;
+ }
+
+ @Override
+ public void startRecipeProcessing() {
+ if (mRealInventory == null) return;
+ if (mRealInventory.used) {
+ mState = State.Blocked;
+ } else {
+ mRealInventory.used = true;
+ mState = State.Activated;
+ }
+ }
+
+ @Override
+ public CheckRecipeResult endRecipeProcessing(MTEMultiBlockBase controller) {
+ if (mState == State.Activated) {
+ assert mRealInventory != null;
+ mRealInventory.used = false;
+ }
+ mState = State.Default;
+ return CheckRecipeResultRegistry.SUCCESSFUL;
+ }
+
+ @Override
+ public void updateSlots() {
+ if (mChannel == null || mRealInventory == null) return;
+ for (int i = 0; i < mRealInventory.stacks.length; i++) {
+ if (mRealInventory.stacks[i] != null
+ && (mRealInventory.stacks[i].getItem() == null || mRealInventory.stacks[i].stackSize <= 0))
+ mRealInventory.stacks[i] = null;
+ }
+ if (!mRealInventory.disableSort) fillStacksIntoFirstSlots();
+ markDirty();
+ getWorldSave().markDirty();
+ }
+
+ @Override
+ protected void fillStacksIntoFirstSlots() {
+ // sanity check
+ if (mRealInventory == null) return;
+ final int L = SIZE_INVENTORY;
+ HashMap<GTUtility.ItemId, Integer> slots = new HashMap<>(L);
+ HashMap<GTUtility.ItemId, ItemStack> stacks = new HashMap<>(L);
+ List<GTUtility.ItemId> order = new ArrayList<>(L);
+ List<Integer> validSlots = new ArrayList<>(L);
+ for (int i = 0; i < L; i++) {
+ validSlots.add(i);
+ ItemStack s = mRealInventory.stacks[i];
+ if (s == null) continue;
+ GTUtility.ItemId sID = GTUtility.ItemId.createNoCopy(s);
+ slots.merge(sID, s.stackSize, Integer::sum);
+ if (!stacks.containsKey(sID)) stacks.put(sID, s);
+ order.add(sID);
+ mRealInventory.stacks[i] = null;
+ }
+ int slotindex = 0;
+ for (GTUtility.ItemId sID : order) {
+ int toSet = slots.get(sID);
+ if (toSet == 0) continue;
+ int slot = validSlots.get(slotindex);
+ slotindex++;
+ mRealInventory.stacks[slot] = stacks.get(sID)
+ .copy();
+ toSet = Math.min(toSet, mRealInventory.stacks[slot].getMaxStackSize());
+ mRealInventory.stacks[slot].stackSize = toSet;
+ slots.merge(sID, toSet, (a, b) -> a - b);
+ }
+ }
+
+ private void dropItems(ItemStack[] aStacks) {
+ for (ItemStack stack : aStacks) {
+ if (!GTUtility.isStackValid(stack)) continue;
+ EntityItem ei = new EntityItem(
+ getBaseMetaTileEntity().getWorld(),
+ getBaseMetaTileEntity().getOffsetX(getBaseMetaTileEntity().getFrontFacing(), 1) + 0.5,
+ getBaseMetaTileEntity().getOffsetY(getBaseMetaTileEntity().getFrontFacing(), 1) + 0.5,
+ getBaseMetaTileEntity().getOffsetZ(getBaseMetaTileEntity().getFrontFacing(), 1) + 0.5,
+ stack);
+ ei.motionX = ei.motionY = ei.motionZ = 0;
+ getBaseMetaTileEntity().getWorld()
+ .spawnEntityInWorld(ei);
+ }
+ }
+
+ @Override
+ public boolean shouldDropItemAt(int index) {
+ // NOTE by this time onBlockDestroyed has already been called, i.e. so ref has already been decremented.
+ // so we really should check for ref <= 0 instead of ref <= 1
+ return mRealInventory != null && mRealInventory.ref <= 0;
+ }
+
+ @Override
+ public void onBlockDestroyed() {
+ super.onBlockDestroyed();
+ if (mRealInventory != null) {
+ if (--mRealInventory.ref <= 0) getWorldSave().remove(mChannel);
+ }
+ }
+
+ @Override
+ public void saveNBTData(NBTTagCompound aNBT) {
+ super.saveNBTData(aNBT);
+ if (mChannel != null) aNBT.setString("channel", mChannel);
+ aNBT.setBoolean("private", mPrivate);
+ }
+
+ @Override
+ public void loadNBTData(NBTTagCompound aNBT) {
+ super.loadNBTData(aNBT);
+ String channel = aNBT.getString("channel");
+ if ("".equals(channel)) channel = null;
+ this.mChannel = channel;
+ mPrivate = aNBT.getBoolean("private");
+ }
+
+ public String getChannel() {
+ return mChannel;
+ }
+
+ @Override
+ public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) {
+ super.onFirstTick(aBaseMetaTileEntity);
+ if (mChannel != null) {
+ mRealInventory = getWorldSave().get(getRealChannel());
+ handler.set(mRealInventory.stacks);
+ }
+ }
+
+ @Override
+ public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+ if (!getBaseMetaTileEntity().getCoverBehaviorAtSideNew(side)
+ .isGUIClickable(
+ side,
+ getBaseMetaTileEntity().getCoverIDAtSide(side),
+ getBaseMetaTileEntity().getComplexCoverDataAtSide(side),
+ getBaseMetaTileEntity()))
+ return;
+ if (aPlayer.isSneaking()) {
+ if (this.mRealInventory == null) {
+ aPlayer.addChatMessage(new ChatComponentTranslation("ggfab.info.linked_input_bus.no_channel"));
+ return;
+ }
+ if (mRealInventory.disableSort) {
+ mRealInventory.disableSort = false;
+ } else {
+ if (mRealInventory.disableLimited) {
+ mRealInventory.disableLimited = false;
+ } else {
+ mRealInventory.disableSort = true;
+ mRealInventory.disableLimited = true;
+ }
+ }
+ GTUtility.sendChatToPlayer(
+ aPlayer,
+ StatCollector.translateToLocal("GT5U.hatch.disableSort." + mRealInventory.disableSort) + " "
+ + StatCollector.translateToLocal("GT5U.hatch.disableLimited." + mRealInventory.disableLimited));
+ } else {
+ this.disableFilter = !this.disableFilter;
+ GTUtility.sendChatToPlayer(
+ aPlayer,
+ StatCollector.translateToLocal("GT5U.hatch.disableFilter." + this.disableFilter));
+ }
+ }
+
+ @Override
+ public NBTTagCompound getCopiedData(EntityPlayer player) {
+ if (getChannel() == null) {
+ return null;
+ }
+ NBTTagCompound tag = new NBTTagCompound();
+ tag.setString("type", COPIED_DATA_IDENTIFIER);
+ tag.setString("channel", getChannel());
+ tag.setTag("circuit", GTUtility.saveItem(getStackInSlot(getCircuitSlot())));
+ if (isPrivate()) {
+ tag.setLong(
+ "owner1",
+ getBaseMetaTileEntity().getOwnerUuid()
+ .getMostSignificantBits());
+ tag.setLong(
+ "owner2",
+ getBaseMetaTileEntity().getOwnerUuid()
+ .getLeastSignificantBits());
+ }
+ return tag;
+ }
+
+ @Override
+ public boolean pasteCopiedData(EntityPlayer player, NBTTagCompound nbt) {
+ // backwards compat
+ if (nbt == null || (!COPIED_DATA_IDENTIFIER.equals(nbt.getString("ggfab.type"))
+ && !COPIED_DATA_IDENTIFIER.equals(nbt.getString("type")))) {
+ return false;
+ }
+ ItemStack circuit = GTUtility.loadItem(nbt, "circuit");
+ String channel = nbt.getString("channel");
+ if (GTUtility.isStackInvalid(circuit)) circuit = null;
+ if ("".equals(channel)) {
+ return false;
+ } else if (circuit != null && getConfigurationCircuits().stream()
+ .noneMatch(circuit::isItemEqual)) {
+ return false;
+ }
+ UUID owner = nbt.hasKey("owner1") ? new UUID(nbt.getLong("owner1"), nbt.getLong("owner2")) : null;
+ if (owner != null && !owner.equals(getBaseMetaTileEntity().getOwnerUuid())) {
+ return false;
+ }
+ setPrivate(owner != null);
+ setChannel(channel);
+ setInventorySlotContents(getCircuitSlot(), circuit);
+ return true;
+ }
+
+ @Override
+ public String getCopiedDataIdentifier(EntityPlayer player) {
+ return COPIED_DATA_IDENTIFIER;
+ }
+
+ @Override
+ public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, ForgeDirection side,
+ float aX, float aY, float aZ) {
+ if (!(aPlayer instanceof EntityPlayerMP))
+ return super.onRightclick(aBaseMetaTileEntity, aPlayer, side, aX, aY, aZ);
+ ItemStack stick = aPlayer.inventory.getCurrentItem();
+ if (!ItemList.Tool_DataStick.isStackEqual(stick, false, true))
+ return super.onRightclick(aBaseMetaTileEntity, aPlayer, side, aX, aY, aZ);
+ if (!stick.hasTagCompound() || !COPIED_DATA_IDENTIFIER.equals(stick.stackTagCompound.getString("ggfab.type"))) {
+ aPlayer.addChatMessage(new ChatComponentTranslation("ggfab.info.linked_input_bus.no_data"));
+ return true;
+ }
+ ItemStack circuit = GTUtility.loadItem(stick.stackTagCompound, "circuit");
+ String channel = stick.stackTagCompound.getString("channel");
+ if (GTUtility.isStackInvalid(circuit)) circuit = null;
+ if ("".equals(channel)) {
+ aPlayer.addChatMessage(new ChatComponentTranslation("ggfab.info.linked_input_bus.no_data"));
+ return true;
+ } else if (circuit != null && getConfigurationCircuits().stream()
+ .noneMatch(circuit::isItemEqual)) {
+ aPlayer.addChatMessage(new ChatComponentTranslation("ggfab.info.linked_input_bus.invalid_circuit"));
+ return true;
+ }
+ UUID owner = stick.stackTagCompound.hasKey("owner1")
+ ? new UUID(stick.stackTagCompound.getLong("owner1"), stick.stackTagCompound.getLong("owner2"))
+ : null;
+ if (owner != null && !owner.equals(getBaseMetaTileEntity().getOwnerUuid())) {
+ aPlayer.addChatMessage(new ChatComponentTranslation("ggfab.info.linked_input_bus.not_owned"));
+ return true;
+ }
+ setPrivate(owner != null);
+ setChannel(channel);
+ setInventorySlotContents(getCircuitSlot(), circuit);
+ aPlayer.addChatMessage(new ChatComponentTranslation("ggfab.info.linked_input_bus.data_pasted", channel));
+ return true;
+ }
+
+ @Override
+ public void onLeftclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+ if (!(aPlayer instanceof EntityPlayerMP)) return;
+ ItemStack stick = aPlayer.inventory.getCurrentItem();
+ if (!ItemList.Tool_DataStick.isStackEqual(stick, false, true)) return;
+ if (getChannel() == null) {
+ aPlayer.addChatMessage(new ChatComponentTranslation("ggfab.info.linked_input_bus.no_channel"));
+ return;
+ }
+ aPlayer.addChatMessage(new ChatComponentTranslation("ggfab.info.linked_input_bus.data_copied", getChannel()));
+ stick.stackTagCompound = getCopiedData(aPlayer);
+ stick.setStackDisplayName("Linked Input Bus configuration");
+ // abuse the title mechanism here. I assure you it will be fine (tm).
+ GTUtility.ItemNBT.setBookTitle(stick, "Channel: " + getChannel());
+ if (getBaseMetaTileEntity().getOwnerName() != null)
+ GTUtility.ItemNBT.setBookAuthor(stick, getBaseMetaTileEntity().getOwnerName());
+ }
+
+ private String getRealChannel() {
+ if (mChannel == null) return null;
+ if (mPrivate) return getBaseMetaTileEntity().getOwnerUuid() + mChannel;
+ return new UUID(0, 0) + mChannel;
+ }
+
+ public boolean isPrivate() {
+ return mPrivate;
+ }
+
+ public void setPrivate(boolean aPrivate) {
+ if (aPrivate == mPrivate) return;
+ if (getBaseMetaTileEntity().isClientSide()) {
+ mPrivate = aPrivate;
+ return;
+ }
+ if (this.mChannel == null) {
+ mPrivate = aPrivate;
+ return;
+ }
+ getWorldSave().markDirty();
+ if (--this.mRealInventory.ref <= 0) {
+ // last referrer, drop inventory
+ dropItems(mRealInventory.stacks);
+ getWorldSave().remove(getRealChannel());
+ }
+ mPrivate = aPrivate;
+ mRealInventory = getWorldSave().get(getRealChannel());
+ this.handler.set(mRealInventory.stacks);
+ mRealInventory.ref++;
+ getWorldSave().markDirty();
+ }
+
+ public void setChannel(String aChannel) {
+ if ("".equals(aChannel)) aChannel = null;
+ if (getBaseMetaTileEntity().isClientSide()) {
+ mChannel = aChannel;
+ return;
+ }
+ if (Objects.equals(this.mChannel, aChannel)) return; // noop
+ if (this.mChannel != null) {
+ if (--this.mRealInventory.ref <= 0) {
+ // last referrer, drop inventory
+ dropItems(mRealInventory.stacks);
+ getWorldSave().remove(getRealChannel());
+ }
+ }
+ if (aChannel == null) {
+ this.mChannel = null;
+ this.mRealInventory = null;
+ this.handler.setFake();
+ } else {
+ this.mChannel = aChannel;
+ this.mRealInventory = getWorldSave().get(getRealChannel());
+ this.handler.set(mRealInventory.stacks);
+ mRealInventory.ref++;
+ }
+ getWorldSave().markDirty();
+ }
+
+ private WorldSave getWorldSave() {
+ if (save == null) {
+ WorldSave save = (WorldSave) getBaseMetaTileEntity().getWorld()
+ .loadItemData(WorldSave.class, "LinkedInputBusses");
+ if (save == null) {
+ save = new WorldSave("LinkedInputBusses");
+ getBaseMetaTileEntity().getWorld()
+ .setItemData(save.mapName, save);
+ }
+ this.save = save;
+ }
+ return save;
+ }
+
+ private enum State {
+ Activated,
+ Blocked,
+ Default,
+ }
+
+ private static class SharedInventory {
+
+ private final ItemStack[] stacks;
+ /**
+ * Inventory wrapper for ModularUI
+ */
+ private final ItemStackHandler inventoryHandler;
+ public boolean disableLimited = true;
+ public boolean disableSort;
+ private boolean used;
+ private int ref;
+
+ public SharedInventory() {
+ this.stacks = new ItemStack[SIZE_INVENTORY];
+ inventoryHandler = new ItemStackHandler(stacks);
+ }
+
+ public SharedInventory(NBTTagCompound tag) {
+ this.stacks = new ItemStack[SIZE_INVENTORY];
+ inventoryHandler = new ItemStackHandler(stacks);
+
+ for (int i = 0; i < SIZE_INVENTORY; i++) {
+ String key = "" + i;
+ if (!tag.hasKey(key, Constants.NBT.TAG_COMPOUND)) continue;
+ stacks[i] = ItemStack.loadItemStackFromNBT(tag.getCompoundTag(key));
+ }
+
+ ref = tag.getInteger("ref");
+ disableLimited = tag.getBoolean("dl");
+ disableSort = tag.getBoolean("ds");
+ }
+
+ public NBTTagCompound save() {
+ NBTTagCompound tag = new NBTTagCompound();
+ for (int i = 0; i < SIZE_INVENTORY; i++) {
+ ItemStack stack = stacks[i];
+ if (stack == null) continue;
+ tag.setTag("" + i, stack.writeToNBT(new NBTTagCompound()));
+ }
+ tag.setInteger("ref", ref);
+ tag.setBoolean("ds", disableSort);
+ tag.setBoolean("dl", disableLimited);
+ return tag;
+ }
+ }
+
+ public static class WorldSave extends WorldSavedData {
+
+ private final Map<String, SharedInventory> data = new HashMap<>();
+
+ public WorldSave(String p_i2141_1_) {
+ super(p_i2141_1_);
+ }
+
+ @Override
+ public void readFromNBT(NBTTagCompound tag) {
+ data.clear();
+ @SuppressWarnings("unchecked")
+ Set<Map.Entry<String, NBTBase>> set = tag.tagMap.entrySet();
+ for (Map.Entry<String, NBTBase> e : set) {
+ data.put(e.getKey(), new SharedInventory((NBTTagCompound) e.getValue()));
+ }
+ }
+
+ @Override
+ public void writeToNBT(NBTTagCompound tag) {
+ for (Map.Entry<String, SharedInventory> e : data.entrySet()) {
+ if (e.getValue().ref > 0) tag.setTag(
+ e.getKey(),
+ e.getValue()
+ .save());
+ }
+ }
+
+ public SharedInventory get(Object channel) {
+ return data.computeIfAbsent(channel.toString(), k -> new SharedInventory());
+ }
+
+ public void remove(Object channel) {
+ data.remove(channel.toString());
+ markDirty();
+ }
+ }
+
+ private static class ItemStackHandlerProxy extends ItemStackHandler {
+
+ private static final ItemStack[] EMPTY = new ItemStack[SIZE_INVENTORY];
+ private boolean fake;
+
+ public ItemStackHandlerProxy() {
+ super(EMPTY);
+ fake = true;
+ }
+
+ public void setFake() {
+ set(EMPTY);
+ fake = true;
+ }
+
+ public boolean isFake() {
+ return fake;
+ }
+
+ public void set(ItemStack[] stacks) {
+ this.stacks = Arrays.asList(stacks);
+ fake = false;
+ }
+
+ @Override
+ public NBTTagCompound serializeNBT() {
+ NBTTagCompound tag = super.serializeNBT();
+ tag.setBoolean("fake", fake);
+ return tag;
+ }
+
+ @Override
+ public void deserializeNBT(NBTTagCompound nbt) {
+ super.deserializeNBT(nbt);
+ fake = nbt.getBoolean("fake");
+ }
+ }
+}
diff --git a/src/main/java/ggfab/mui/ClickableTextWidget.java b/src/main/java/ggfab/mui/ClickableTextWidget.java
new file mode 100644
index 0000000000..03843eef31
--- /dev/null
+++ b/src/main/java/ggfab/mui/ClickableTextWidget.java
@@ -0,0 +1,58 @@
+package ggfab.mui;
+
+import java.util.Arrays;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.gtnewhorizons.modularui.api.drawable.IDrawable;
+import com.gtnewhorizons.modularui.api.drawable.Text;
+import com.gtnewhorizons.modularui.api.drawable.TextRenderer;
+import com.gtnewhorizons.modularui.api.math.Size;
+import com.gtnewhorizons.modularui.api.widget.Widget;
+import com.gtnewhorizons.modularui.common.widget.ButtonWidget;
+
+public class ClickableTextWidget extends ButtonWidget {
+
+ private Text caption;
+ private int maxLines = 1;
+ private int marginInLines = 1;
+
+ public ClickableTextWidget(Text caption) {
+ super();
+ this.caption = caption;
+ super.setBackground(caption);
+ }
+
+ public ClickableTextWidget setText(Text caption) {
+ this.caption = caption;
+ return this;
+ }
+
+ public ClickableTextWidget setMaxLines(int maxLines) {
+ this.maxLines = maxLines;
+ return this;
+ }
+
+ public ClickableTextWidget setMarginInLines(int margin) {
+ this.marginInLines = margin;
+ return this;
+ }
+
+ @Override
+ public Widget setBackground(IDrawable... drawables) {
+ IDrawable[] all = Arrays.copyOf(drawables, drawables.length + 1);
+ all[drawables.length] = caption;
+ return super.setBackground(all);
+ }
+
+ @Override
+ protected @NotNull Size determineSize(int maxWidth, int maxHeight) {
+ if (caption == null) return super.determineSize(maxWidth, maxHeight);
+ return new Size(
+ Math.min(
+ maxWidth,
+ TextRenderer.getFontRenderer()
+ .getStringWidth(caption.getFormatted())),
+ (maxLines + marginInLines) * TextRenderer.getFontRenderer().FONT_HEIGHT);
+ }
+}
diff --git a/src/main/java/ggfab/util/GGUtils.java b/src/main/java/ggfab/util/GGUtils.java
new file mode 100644
index 0000000000..7dd70ed759
--- /dev/null
+++ b/src/main/java/ggfab/util/GGUtils.java
@@ -0,0 +1,78 @@
+package ggfab.util;
+
+import java.util.StringJoiner;
+
+import net.minecraft.util.ChunkCoordinates;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+
+public class GGUtils {
+
+ public static boolean isValidTile(IGregTechTileEntity tile) {
+ return tile != null && !tile.isDead()
+ && tile.getMetaTileEntity() != null
+ && tile.getMetaTileEntity()
+ .getBaseMetaTileEntity() == tile;
+ }
+
+ public static boolean isValidTile(IMetaTileEntity mte) {
+ return mte != null && mte.getBaseMetaTileEntity() != null
+ && mte.getBaseMetaTileEntity()
+ .getMetaTileEntity() == mte
+ && !mte.getBaseMetaTileEntity()
+ .isDead();
+ }
+
+ public static ChunkCoordinates translate(ChunkCoordinates origin, ForgeDirection direction) {
+ return new ChunkCoordinates(
+ origin.posX + direction.offsetX,
+ origin.posY + direction.offsetY,
+ origin.posZ + direction.offsetZ);
+ }
+
+ public static String formatTileInfo(String prefix, IMetaTileEntity mte, String delimiter, String suffix) {
+ if (!isValidTile(mte)) return prefix + "N/A" + suffix;
+ StringJoiner sj = new StringJoiner(delimiter, prefix, suffix);
+ IGregTechTileEntity til = mte.getBaseMetaTileEntity();
+ sj.add(String.valueOf(til.getXCoord()));
+ sj.add(String.valueOf(til.getYCoord()));
+ sj.add(String.valueOf(til.getZCoord()));
+ return sj.toString();
+ }
+
+ public static String formatTileInfo(String prefix, IGregTechTileEntity tile, String delimiter, String suffix) {
+ if (!isValidTile(tile)) return prefix + "N/A" + suffix;
+ StringJoiner sj = new StringJoiner(delimiter, prefix, suffix);
+ sj.add(String.valueOf(tile.getXCoord()));
+ sj.add(String.valueOf(tile.getYCoord()));
+ sj.add(String.valueOf(tile.getZCoord()));
+ return sj.toString();
+ }
+
+ /**
+ * convert lowerCamelCase to any of snake case or normal sentence
+ */
+ public static String processSentence(String src, Character separator, boolean capitalize, boolean firstCapitalize) {
+ if (src == null) throw new IllegalArgumentException();
+ if (src.isEmpty()) return "";
+ StringBuilder out = new StringBuilder(src.length());
+ if (firstCapitalize) out.append(Character.toUpperCase(src.charAt(0)));
+ else out.append(src.charAt(0));
+ for (int i = 1; i < src.length(); i++) {
+ char ch = src.charAt(i);
+ if (Character.isUpperCase(ch)) {
+ if (separator != null) out.append(separator.charValue());
+ if (capitalize) {
+ out.append(ch);
+ } else {
+ out.append(Character.toLowerCase(ch));
+ }
+ } else {
+ out.append(ch);
+ }
+ }
+ return out.toString();
+ }
+}
diff --git a/src/main/java/ggfab/util/OverclockHelper.java b/src/main/java/ggfab/util/OverclockHelper.java
new file mode 100644
index 0000000000..b0e42930e8
--- /dev/null
+++ b/src/main/java/ggfab/util/OverclockHelper.java
@@ -0,0 +1,75 @@
+package ggfab.util;
+
+import gregtech.api.util.GTUtility;
+
+public class OverclockHelper {
+
+ public static OverclockOutput normalOverclock(long recipeEUt, int duration, long inputVoltage, boolean perfectOC) {
+ if (recipeEUt > inputVoltage) return null;
+ int recipeTier = Math.max(1, GTUtility.getTier(recipeEUt)); // ULV no overclock
+ int machineTier = GTUtility.getTier(inputVoltage);
+ int shift = perfectOC ? 2 : 1;
+ while (recipeTier < machineTier && duration > 1) {
+ duration >>= shift;
+ recipeEUt <<= 2;
+ recipeTier++;
+ }
+ return new OverclockOutput(recipeEUt, duration);
+ }
+
+ public static OverclockOutput laserOverclock(long recipeEUt, int duration, long inputEUt,
+ float penaltyIncreaseFactor) {
+ if (recipeEUt > inputEUt) return null;
+ float currentPenalty = 4 + penaltyIncreaseFactor;
+ // 2/(n+k) overclock until energy hatch is crying
+ // must ensure it doesn't go to negative after overclock
+ while (recipeEUt * currentPenalty > 0 && recipeEUt * currentPenalty < inputEUt && duration > 1) {
+ duration >>= 1;
+ recipeEUt *= currentPenalty;
+ currentPenalty += penaltyIncreaseFactor;
+ }
+ return new OverclockOutput(recipeEUt, duration);
+ }
+
+ public static final class OverclockOutput {
+
+ private final long mEUt;
+ private final int mDuration;
+
+ public OverclockOutput(long aEUt, int aDuration) {
+ this.mEUt = aEUt;
+ this.mDuration = aDuration;
+ }
+
+ public long getEUt() {
+ return mEUt;
+ }
+
+ public int getDuration() {
+ return mDuration;
+ }
+
+ @Override
+ public String toString() {
+ return mEUt + "@" + mDuration + "ticks";
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (!(o instanceof OverclockOutput)) return false;
+
+ OverclockOutput that = (OverclockOutput) o;
+
+ if (mEUt != that.mEUt) return false;
+ return mDuration == that.mDuration;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = (int) (mEUt ^ (mEUt >>> 32));
+ result = 31 * result + mDuration;
+ return result;
+ }
+ }
+}
generated by cgit (git 2.46.0) at 2025-03-04 08:41:43 +0000