Implement Linear Forging Furnace

src/main/java/gregicality/multiblocks/api/capability/impl/GCYMHeatingCoilRecipeLogic.java

@@ -0,0 +1,33 @@
+package gregicality.multiblocks.api.capability.impl;
+
+import org.jetbrains.annotations.NotNull;
+
+import gregtech.api.capability.IHeatingCoil;
+import gregtech.api.metatileentity.multiblock.RecipeMapMultiblockController;
+import gregtech.api.recipes.logic.OverclockingLogic;
+import gregtech.api.recipes.recipeproperties.IRecipePropertyStorage;
+import gregtech.api.recipes.recipeproperties.TemperatureProperty;
+
+public class GCYMHeatingCoilRecipeLogic extends GCYMMultiblockRecipeLogic {
+
+ public GCYMHeatingCoilRecipeLogic(RecipeMapMultiblockController metaTileEntity) {
+ super(metaTileEntity);
+ if (!(metaTileEntity instanceof IHeatingCoil)) {
+ throw new IllegalArgumentException("MetaTileEntity must be instanceof IHeatingCoil");
+ }
+ }
+
+ protected void modifyOverclockPre(@NotNull int[] values, @NotNull IRecipePropertyStorage storage) {
+ super.modifyOverclockPre(values, storage);
+ values[0] = OverclockingLogic.applyCoilEUtDiscount(values[0],
+ ((IHeatingCoil) this.metaTileEntity).getCurrentTemperature(),
+ (Integer) storage.getRecipePropertyValue(TemperatureProperty.getInstance(), 0));
+ }
+
+ protected @NotNull int[] runOverclockingLogic(@NotNull IRecipePropertyStorage propertyStorage, int recipeEUt,
+ long maxVoltage, int duration, int amountOC) {
+ return OverclockingLogic.heatingCoilOverclockingLogic(Math.abs(recipeEUt), maxVoltage, duration, amountOC,
+ ((IHeatingCoil) this.metaTileEntity).getCurrentTemperature(),
+ (Integer) propertyStorage.getRecipePropertyValue(TemperatureProperty.getInstance(), 0));
+ }
+}

src/main/java/gregicality/multiblocks/api/metatileentity/GCYMMultiShapeMultiblockController.java

@@ -0,0 +1,44 @@
+package gregicality.multiblocks.api.metatileentity;
+
+import net.minecraft.util.ResourceLocation;
+
+import org.jetbrains.annotations.NotNull;
+
+import gregtech.api.metatileentity.interfaces.IGregTechTileEntity;
+import gregtech.api.pattern.BlockPattern;
+import gregtech.api.recipes.RecipeMap;
+
+public abstract class GCYMMultiShapeMultiblockController extends GCYMRecipeMapMultiblockController {
+
+ public GCYMMultiShapeMultiblockController(ResourceLocation metaTileEntityId, RecipeMap<?>[] recipeMaps) {
+ super(metaTileEntityId, recipeMaps);
+ }
+
+ @Override
+ protected @NotNull BlockPattern createStructurePattern() {
+ if (this.getWorld() != null && this.getPos() != null) {
+ if (this.getWorld().getTileEntity(this.getPos()) instanceof IGregTechTileEntity gtte) {
+ if (gtte.getMetaTileEntity() instanceof GCYMMultiShapeMultiblockController controller) {
+ return getStructurePattern(controller.getRecipeMapIndex());
+ }
+ }
+ }
+ return getStructurePattern(0);
+ }
+
+ protected abstract @NotNull BlockPattern getStructurePattern(int index);
+
+ @Override
+ public void checkStructurePattern() {
+ if (!this.isStructureFormed()) {
+ this.reinitializeStructurePattern();
+ }
+ super.checkStructurePattern();
+ }
+
+ @Override
+ public void setRecipeMapIndex(int index) {
+ super.setRecipeMapIndex(index);
+ this.reinitializeStructurePattern();
+ }
+}

src/main/java/gregicality/multiblocks/api/recipeproperties/LFFRecipeTypeProperty.java

@@ -0,0 +1,33 @@
+package gregicality.multiblocks.api.recipeproperties;
+
+import net.minecraft.client.Minecraft;
+
+import gregtech.api.recipes.recipeproperties.RecipeProperty;
+
+import gregicality.multiblocks.api.recipes.LinearForgingFurnaceRecipeType;
+
+public class LFFRecipeTypeProperty extends RecipeProperty<LinearForgingFurnaceRecipeType> {
+
+ public static final String KEY = "lff_recipe_type";
+
+ private static LFFRecipeTypeProperty INSTANCE;
+
+ protected LFFRecipeTypeProperty() {
+ super(KEY, LinearForgingFurnaceRecipeType.class);
+ }
+
+ public static LFFRecipeTypeProperty getInstance() {
+ if (INSTANCE == null) {
+ INSTANCE = new LFFRecipeTypeProperty();
+ }
+ return INSTANCE;
+ }
+
+ @Override
+ public void drawInfo(Minecraft minecraft, int x, int y, int color, Object value) {}
+
+ @Override
+ public int getInfoHeight(Object value) {
+ return 0;
+ }
+}

src/main/java/gregicality/multiblocks/api/recipes/GCYMRecipeMaps.java

@@ -1,7 +1,12 @@
 package gregicality.multiblocks.api.recipes;
 
+import java.util.List;
+
+import com.google.common.collect.Lists;
+
 import gregtech.api.gui.GuiTextures;
 import gregtech.api.recipes.RecipeMap;
+import gregtech.api.recipes.RecipeMaps;
 import gregtech.api.recipes.builders.BlastRecipeBuilder;
 import gregtech.core.sound.GTSoundEvents;
 
@@ -17,5 +22,42 @@ public final class GCYMRecipeMaps {
  .setSlotOverlay(true, true, true, GuiTextures.FURNACE_OVERLAY_2)
  .setSound(GTSoundEvents.FURNACE);
 
+ public static final RecipeMap<?>[] LINEAR_FORGING_RECIPES = new RecipeMap[] {
+ RecipeMaps.BLAST_RECIPES,
+ ALLOY_BLAST_RECIPES,
+ new RecipeMap<>("lff_dual", 9, 3, 3, 1, new BlastRecipeBuilder(), false)
+ .setSlotOverlay(false, false, false, GuiTextures.FURNACE_OVERLAY_1)
+ .setSlotOverlay(false, true, false, GuiTextures.FURNACE_OVERLAY_2)
+ .setSlotOverlay(true, true, false, GuiTextures.FURNACE_OVERLAY_2)
+ .setSound(GTSoundEvents.FURNACE),
+ RecipeMaps.VACUUM_RECIPES,
+ new RecipeMap<>("lff_blast_cooled", 6, 3, 3, 2, new BlastRecipeBuilder(), false),
+ new RecipeMap<>("lff_alloy_cooled", 12, 1, 4, 2, new BlastRecipeBuilder(), false)
+ .setSlotOverlay(false, false, false, GuiTextures.FURNACE_OVERLAY_1)
+ .setSlotOverlay(false, false, true, GuiTextures.FURNACE_OVERLAY_1)
+ .setSlotOverlay(false, true, false, GuiTextures.FURNACE_OVERLAY_2)
+ .setSlotOverlay(true, true, false, GuiTextures.FURNACE_OVERLAY_2)
+ .setSound(GTSoundEvents.FURNACE),
+ new RecipeMap<>("lff_dual_cooled", 12, 3, 4, 2, new BlastRecipeBuilder(), false)
+ .setSlotOverlay(false, false, false, GuiTextures.FURNACE_OVERLAY_1)
+ .setSlotOverlay(false, true, false, GuiTextures.FURNACE_OVERLAY_2)
+ .setSlotOverlay(true, true, false, GuiTextures.FURNACE_OVERLAY_2)
+ .setSound(GTSoundEvents.FURNACE),
+ new RecipeMap<>("lff_blast_forging_cooled", 6, 3, 3, 2, new BlastRecipeBuilder(), false),
+ new RecipeMap<>("lff_alloy_forging_cooled", 12, 1, 4, 2, new BlastRecipeBuilder(), false)
+ .setSlotOverlay(false, false, false, GuiTextures.FURNACE_OVERLAY_1)
+ .setSlotOverlay(false, false, true, GuiTextures.FURNACE_OVERLAY_1)
+ .setSlotOverlay(false, true, false, GuiTextures.FURNACE_OVERLAY_2)
+ .setSlotOverlay(true, true, false, GuiTextures.FURNACE_OVERLAY_2)
+ .setSound(GTSoundEvents.FURNACE),
+ new RecipeMap<>("lff_dual_forging_cooled", 12, 3, 4, 2, new BlastRecipeBuilder(), false)
+ .setSlotOverlay(false, false, false, GuiTextures.FURNACE_OVERLAY_1)
+ .setSlotOverlay(false, true, false, GuiTextures.FURNACE_OVERLAY_2)
+ .setSlotOverlay(true, true, false, GuiTextures.FURNACE_OVERLAY_2)
+ .setSound(GTSoundEvents.FURNACE)
+ };
+
+ static final List<RecipeMap<?>> LFF_RECIPES_AS_LIST = Lists.newArrayList(GCYMRecipeMaps.LINEAR_FORGING_RECIPES);
+
  private GCYMRecipeMaps() {}
 }

src/main/java/gregicality/multiblocks/api/recipes/LinearForgingFurnaceRecipeType.java

@@ -0,0 +1,12 @@
+package gregicality.multiblocks.api.recipes;
+
+public enum LinearForgingFurnaceRecipeType {
+
+ NONE,
+ BLAST,
+ ALLOY,
+ BLAST_COOLED,
+ ALLOY_COOLED,
+ BLAST_FORGING_COOLED,
+ ALLOY_FORGING_COOLED;
+}

src/main/java/gregicality/multiblocks/api/render/GCYMTextures.java

@@ -41,6 +41,7 @@ public final class GCYMTextures {
  public static OrientedOverlayRenderer MEGA_BLAST_FURNACE_OVERLAY;
  public static OrientedOverlayRenderer MEGA_VACUUM_FREEZER_OVERLAY;
  public static OrientedOverlayRenderer STEAM_ENGINE_OVERLAY;
+ public static OrientedOverlayRenderer LINEAR_FORGING_FURNACE_OVERLAY;
 
  // Hatches
  public static OrientedOverlayRenderer PARALLEL_HATCH_MK1_OVERLAY;
@@ -63,6 +64,7 @@ public final class GCYMTextures {
  public static SimpleOverlayRenderer ENGRAVER_CASING;
  public static SimpleOverlayRenderer ATOMIC_CASING;
  public static SimpleOverlayRenderer STEAM_CASING;
+ public static SimpleOverlayRenderer FORGING_CASING;
 
  private GCYMTextures() {}
 
@@ -97,6 +99,7 @@ public static void preInit() {
  MEGA_BLAST_FURNACE_OVERLAY = new OrientedOverlayRenderer("multiblock/mega_blast_furnace");
  MEGA_VACUUM_FREEZER_OVERLAY = new OrientedOverlayRenderer("multiblock/mega_vacuum_freezer");
  STEAM_ENGINE_OVERLAY = new OrientedOverlayRenderer("multiblock/steam_engine");
+ LINEAR_FORGING_FURNACE_OVERLAY = new OrientedOverlayRenderer("multiblock/linear_forging_furnace");
 
  // Hatches
  PARALLEL_HATCH_MK1_OVERLAY = new OrientedOverlayRenderer("hatches/parallel_hatch_mk1");
@@ -119,5 +122,6 @@ public static void preInit() {
  ENGRAVER_CASING = new SimpleOverlayRenderer("casings/large_multiblock_casing/engraver_casing");
  ATOMIC_CASING = new SimpleOverlayRenderer("casings/large_multiblock_casing/atomic_casing");
  STEAM_CASING = new SimpleOverlayRenderer("casings/large_multiblock_casing/steam_casing");
+ FORGING_CASING = new SimpleOverlayRenderer("casings/large_multiblock_casing/forging_casing");
  }
 }

src/main/java/gregicality/multiblocks/api/unification/GCYMFirstDegreeMaterials.java

@@ -94,5 +94,13 @@ public static void init() {
  .components(Molybdenum, 1, Silicon, 2)
  .blastTemp(2300, BlastProperty.GasTier.MID, GTValues.VA[GTValues.EV], 800)
  .build();
+
+ CobaltAlloy = new Material.Builder(3010, gcymId("cobalt_alloy"))
+ .ingot().fluid()
+ .color(0x6594B2).iconSet(MaterialIconSet.METALLIC)
+ .flags(GENERATE_PLATE, GENERATE_GEAR)
+ .components(Cobalt, 3, Iridium, 3, Aluminium, 1, Tungsten, 1)
+ .blastTemp(5388, BlastProperty.GasTier.HIGH, GTValues.VA[GTValues.IV], 1000)
+ .build();
  }
 }

src/main/java/gregicality/multiblocks/api/unification/GCYMMaterialFlags.java

@@ -20,5 +20,17 @@ public final class GCYMMaterialFlags {
  .requireFlags(NO_ALLOY_BLAST_RECIPES)
  .build();
 
+ /**
+ * Use to disable forging recipes from generating where this material is an input. Not compatible with ore entries.
+ */
+ public static final MaterialFlag NO_FORGING_RECIPES_IN = new MaterialFlag.Builder("no_forging_recipes_in")
+ .build();
+
+ /**
+ * Use to disable forging recipes from forging this material as an output.
+ */
+ public static final MaterialFlag NO_FORGING_OUT = new MaterialFlag.Builder("no_forging_out")
+ .build();
+
  private GCYMMaterialFlags() {}
 }

src/main/java/gregicality/multiblocks/api/unification/GCYMMaterials.java

@@ -17,6 +17,7 @@ public final class GCYMMaterials {
  public static Material TitaniumCarbide;
  public static Material TantalumCarbide;
  public static Material MolybdenumDisilicide;
+ public static Material CobaltAlloy;
 
  /*
  * Second Degree Materials 3020-3039

src/main/java/gregicality/multiblocks/common/CommonProxy.java

@@ -12,6 +12,7 @@
 import net.minecraftforge.event.RegistryEvent;
 import net.minecraftforge.fml.client.event.ConfigChangedEvent;
 import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.registries.IForgeRegistry;
 
@@ -21,6 +22,7 @@
 import gregicality.multiblocks.api.utils.GCYMLog;
 import gregicality.multiblocks.common.block.GCYMMetaBlocks;
 import gregicality.multiblocks.loaders.recipe.GCYMRecipeLoader;
+import gregicality.multiblocks.loaders.recipe.LinearForgingFurnaceLoader;
 
 @Mod.EventBusSubscriber(modid = GregicalityMultiblocks.MODID)
 public class CommonProxy {
@@ -67,4 +69,9 @@ public static void registerRecipes(RegistryEvent.Register<IRecipe> event) {
  // anything here is safe to call removals in
  GCYMRecipeLoader.init();
  }
+
+ @SubscribeEvent(priority = EventPriority.LOWEST)
+ public static void recipesLate(RegistryEvent.Register<IRecipe> event) {
+ LinearForgingFurnaceLoader.registerLate();
+ }
 }

src/main/java/gregicality/multiblocks/common/GCYMConfigHolder.java

@@ -11,10 +11,49 @@ public class GCYMConfigHolder {
  @Config.Name("Global Multiblock Options")
  public static GlobalMultiblocks globalMultiblocks = new GlobalMultiblocks();
 
+ @Config.Comment("Config settings applying to the Linear Forging Furnace")
+ @Config.Name("Linear Forging Furnace Settings")
+ public static LinearForgingFurnaceSettings linearForgingFurnaceSettings = new LinearForgingFurnaceSettings();
+
  public static class GlobalMultiblocks {
 
  @Config.Comment({ "Makes nearly every GCYM Multiblock require blocks which set their maximum voltages.",
  "Default: false" })
  public boolean enableTieredCasings = false;
  }
+
+ public static class LinearForgingFurnaceSettings {
+
+ @Config.Comment({ "Sets the multiplier to duration applied for cooling recipes.",
+ "Default: 1" })
+ @Config.RequiresMcRestart
+ @Config.RangeDouble(
+ min = 0.1,
+ max = 2.0)
+ public double coolingDurationModifier = 1.0;
+
+ @Config.Comment({ "Sets the flat temperature penalty applied for cooling recipes.",
+ "Default: 0" })
+ @Config.RequiresMcRestart
+ @Config.RangeInt(
+ min = 0,
+ max = 2000)
+ public int coolingTemperaturePenalty = 0;
+
+ @Config.Comment({ "Sets the multiplier to duration applied for forging recipes.",
+ "Default: 1.05" })
+ @Config.RequiresMcRestart
+ @Config.RangeDouble(
+ min = 0.1,
+ max = 2.0)
+ public double forgingDurationModifier = 1.05;
+
+ @Config.Comment({ "Sets the flat temperature penalty applied for forging recipes.",
+ "Default: 200" })
+ @Config.RequiresMcRestart
+ @Config.RangeInt(
+ min = 0,
+ max = 2000)
+ public int forgingTemperaturePenalty = 200;
+ }
 }

src/main/java/gregicality/multiblocks/common/block/blocks/BlockLargeMultiblockCasing.java

@@ -44,7 +44,8 @@ public enum CasingType implements IStringSerializable {
  MIXER_CASING("mixer_casing"),
  ENGRAVER_CASING("engraver_casing"),
  ATOMIC_CASING("atomic_casing"),
- STEAM_CASING("steam_casing");
+ STEAM_CASING("steam_casing"),
+ FORGING_CASING("forging_casing");
 
  private final String name;
 

src/main/java/gregicality/multiblocks/common/metatileentities/GCYMMetaTileEntities.java

@@ -6,6 +6,7 @@
 import gregtech.api.GTValues;
 import gregtech.api.GregTechAPI;
 
+import gregicality.multiblocks.common.metatileentities.multiblock.advanced.MetaTileEntityLinearForgingFurnace;
 import gregicality.multiblocks.common.metatileentities.multiblock.generator.MetaTileEntitySteamEngine;
 import gregicality.multiblocks.common.metatileentities.multiblock.standard.*;
 import gregicality.multiblocks.common.metatileentities.multiblockpart.MetaTileEntityParallelHatch;
@@ -41,6 +42,7 @@ public final class GCYMMetaTileEntities {
  public static MetaTileEntityMegaVacuumFreezer MEGA_VACUUM_FREEZER;
  public static MetaTileEntitySteamEngine STEAM_ENGINE;
  public static MetaTileEntityLargeCircuitAssembler LARGE_CIRCUIT_ASSEMBLER;
+ public static MetaTileEntityLinearForgingFurnace LINEAR_FORGING_FURNACE;
 
  public static MetaTileEntityParallelHatch[] PARALLEL_HATCH = new MetaTileEntityParallelHatch[4];
  public static MetaTileEntityTieredHatch[] TIERED_HATCH = new MetaTileEntityTieredHatch[GTValues.V.length];
@@ -88,6 +90,8 @@ public static void init() {
  STEAM_ENGINE = registerMetaTileEntity(2027, new MetaTileEntitySteamEngine(gcymId("steam_engine")));
  LARGE_CIRCUIT_ASSEMBLER = registerMetaTileEntity(2028,
  new MetaTileEntityLargeCircuitAssembler(gcymId("large_circuit_assembler")));
+ LINEAR_FORGING_FURNACE = registerMetaTileEntity(2029,
+ new MetaTileEntityLinearForgingFurnace(gcymId("linear_forging_furnace")));
 
  // Hatches
  for (int i = 0; i < PARALLEL_HATCH.length; i++) {