Added Steam Forge Hammer (#2736)

* Added Steam Forge Hammer

* fix

* Saving tiers in NBT

* fix
update bs

---------

Co-authored-by: Martin Robertz <dream-master@gmx.net>

1 files changed, 389 insertions, 0 deletions

diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/steam/GregtechMetaTileEntity_SteamForgeHammer.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/steam/GregtechMetaTileEntity_SteamForgeHammer.java
new file mode 100644
index 0000000000..1866bfd367
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/steam/GregtechMetaTileEntity_SteamForgeHammer.java
@@ -0,0 +1,389 @@
+package gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.processing.steam;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlocksTiered;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static gregtech.api.GregTech_API.sBlockCasings1;
+import static gregtech.api.GregTech_API.sBlockCasings2;
+import static gregtech.api.enums.GT_Values.AuthorEvgenWarGold;
+import static gregtech.api.util.GT_StructureUtility.buildHatchAdder;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.StatCollector;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.jetbrains.annotations.NotNull;
+
+import com.google.common.collect.ImmutableList;
+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 cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.SoundResource;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.logic.ProcessingLogic;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.recipe.RecipeMap;
+import gregtech.api.recipe.RecipeMaps;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_OverclockCalculator;
+import gregtech.api.util.GT_Recipe;
+import gregtech.common.blocks.GT_Block_Casings1;
+import gregtech.common.blocks.GT_Block_Casings2;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_SteamMultiBase;
+import mcp.mobius.waila.api.IWailaConfigHandler;
+import mcp.mobius.waila.api.IWailaDataAccessor;
+
+public class GregtechMetaTileEntity_SteamForgeHammer
+    extends GregtechMeta_SteamMultiBase<GregtechMetaTileEntity_SteamForgeHammer> implements ISurvivalConstructable {
+
+    public GregtechMetaTileEntity_SteamForgeHammer(String aName) {
+        super(aName);
+    }
+
+    public GregtechMetaTileEntity_SteamForgeHammer(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GregtechMetaTileEntity_SteamForgeHammer(this.mName);
+    }
+
+    @Override
+    public String getMachineType() {
+        return "Forge Hammer";
+    }
+
+    private static final String STRUCTUR_PIECE_MAIN = "main";
+
+    private IStructureDefinition<GregtechMetaTileEntity_SteamForgeHammer> STRUCTURE_DEFINITION = null;
+
+    // spotless:off
+    private final String[][] shape = new String[][] {
+        {"     ","     ","  B  ","     ","     "},
+        {"     ","  A  ","AABAA","  A  ","     "},
+        {"     ","     ","A C A","     ","     "},
+        {"     ","     ","A C A","     ","     "},
+        {"     ","     ","A   A","     ","     "},
+        {"     "," A~A ","AA AA"," AAA ","     "},
+        {" AAA ","AAAAA","AAAAA","AAAAA"," AAA "} };
+    //spotless:on
+
+    private static final int HORIZONTAL_OFF_SET = 2;
+    private static final int VERTICAL_OFF_SET = 5;
+    private static final int DEPTH_OFF_SET = 1;
+
+    private int tierPipeCasing = -1;
+    private int tierMachineCasing = -1;
+
+    private int tCountCasing = 0;
+
+    private int tierMachine = 1;
+
+    private int tierSimpleBlock = -1;
+
+    public static int getTierSimpleBlock(Block block, int meta) {
+        if (block == Blocks.iron_block && meta == 0) return 1;
+        if (block == GregTech_API.sBlockMetal6 && meta == 13) return 2;
+        return 0;
+    }
+
+    public int getTierMachineCasing(Block block, int meta) {
+        if (block == sBlockCasings1 && 10 == meta) {
+            tCountCasing++;
+            return 1;
+        }
+        if (block == sBlockCasings2 && 0 == meta) {
+            tCountCasing++;
+            return 2;
+        }
+        return 0;
+    }
+
+    public static int getTierPipeCasing(Block block, int meta) {
+        if (block == sBlockCasings2 && 12 == meta) return 1;
+        if (block == sBlockCasings2 && 13 == meta) return 2;
+        return 0;
+    }
+
+    protected void updateHatchTexture() {
+        for (GT_MetaTileEntity_Hatch h : mSteamInputs) h.updateTexture(getCasingTextureID());
+        for (GT_MetaTileEntity_Hatch h : mSteamOutputs) h.updateTexture(getCasingTextureID());
+        for (GT_MetaTileEntity_Hatch h : mSteamInputFluids) h.updateTexture(getCasingTextureID());
+    }
+
+    private int getCasingTextureID() {
+        if (tierPipeCasing == 2 || tierMachineCasing == 2 || tierSimpleBlock == 2)
+            return ((GT_Block_Casings2) GregTech_API.sBlockCasings2).getTextureIndex(0);
+        return ((GT_Block_Casings1) GregTech_API.sBlockCasings1).getTextureIndex(10);
+    }
+
+    @Override
+    public void onValueUpdate(byte aValue) {
+        tierMachineCasing = aValue;
+    }
+
+    @Override
+    public byte getUpdateData() {
+        return (byte) tierMachineCasing;
+    }
+
+    @Override
+    protected GT_RenderedTexture getFrontOverlay() {
+        return new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_FORGE_HAMMER);
+    }
+
+    @Override
+    protected GT_RenderedTexture getFrontOverlayActive() {
+        return new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_FORGE_HAMMER_ACTIVE);
+    }
+
+    @Override
+    public ITexture[] getTexture(final IGregTechTileEntity aBaseMetaTileEntity, final ForgeDirection side,
+        final ForgeDirection facing, final int aColorIndex, final boolean aActive, final boolean aRedstone) {
+        if (side == facing) {
+            return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(getCasingTextureID()),
+                aActive ? getFrontOverlayActive() : getFrontOverlay() };
+        }
+        return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(getCasingTextureID()) };
+    }
+
+    @Override
+    public IStructureDefinition<GregtechMetaTileEntity_SteamForgeHammer> getStructureDefinition() {
+        if (STRUCTURE_DEFINITION == null) {
+
+            STRUCTURE_DEFINITION = StructureDefinition.<GregtechMetaTileEntity_SteamForgeHammer>builder()
+
+                .addShape(STRUCTUR_PIECE_MAIN, transpose(shape))
+                .addElement(
+                    'B',
+                    ofBlocksTiered(
+                        GregtechMetaTileEntity_SteamForgeHammer::getTierPipeCasing,
+                        ImmutableList.of(Pair.of(sBlockCasings2, 12), Pair.of(sBlockCasings2, 13)),
+                        -1,
+                        (t, m) -> t.tierPipeCasing = m,
+                        t -> t.tierPipeCasing))
+                .addElement(
+                    'C',
+                    ofBlocksTiered(
+                        GregtechMetaTileEntity_SteamForgeHammer::getTierSimpleBlock,
+                        ImmutableList.of(Pair.of(Blocks.iron_block, 0), Pair.of(GregTech_API.sBlockMetal6, 13)),
+                        -1,
+                        (t, m) -> t.tierSimpleBlock = m,
+                        t -> t.tierSimpleBlock))
+                .addElement(
+                    'A',
+                    ofChain(
+                        buildSteamInput(GregtechMetaTileEntity_SteamForgeHammer.class).casingIndex(10)
+                            .dot(1)
+                            .build(),
+                        buildHatchAdder(GregtechMetaTileEntity_SteamForgeHammer.class)
+                            .atLeast(SteamHatchElement.InputBus_Steam, SteamHatchElement.OutputBus_Steam)
+                            .casingIndex(10)
+                            .dot(1)
+                            .buildAndChain(),
+                        ofBlocksTiered(
+                            this::getTierMachineCasing,
+                            ImmutableList.of(Pair.of(sBlockCasings1, 10), Pair.of(sBlockCasings2, 0)),
+                            -1,
+                            (t, m) -> t.tierMachineCasing = m,
+                            t -> t.tierMachineCasing)))
+                .build();
+
+        }
+        return STRUCTURE_DEFINITION;
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        this.buildPiece(STRUCTUR_PIECE_MAIN, stackSize, hintsOnly, HORIZONTAL_OFF_SET, VERTICAL_OFF_SET, DEPTH_OFF_SET);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (this.mMachine) return -1;
+        return this.survivialBuildPiece(
+            STRUCTUR_PIECE_MAIN,
+            stackSize,
+            HORIZONTAL_OFF_SET,
+            VERTICAL_OFF_SET,
+            DEPTH_OFF_SET,
+            elementBudget,
+            env,
+            false,
+            true);
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        tierPipeCasing = -1;
+        tierMachineCasing = -1;
+        tierSimpleBlock = -1;
+        tCountCasing = 0;
+        if (!checkPiece(STRUCTUR_PIECE_MAIN, HORIZONTAL_OFF_SET, VERTICAL_OFF_SET, DEPTH_OFF_SET)) return false;
+        if (tierPipeCasing < 0 && tierMachineCasing < 0 && tierSimpleBlock < 0) return false;
+        if (tierPipeCasing == 1 && tierMachineCasing == 1
+            && tierSimpleBlock == 1
+            && tCountCasing > 35
+            && !mSteamInputs.isEmpty()
+            && !mSteamOutputs.isEmpty()
+            && !mSteamInputFluids.isEmpty()) {
+            updateHatchTexture();
+            tierMachine = 1;
+            return true;
+        }
+        if (tierPipeCasing == 2 && tierMachineCasing == 2
+            && tierSimpleBlock == 2
+            && tCountCasing > 35
+            && !mSteamInputs.isEmpty()
+            && !mSteamOutputs.isEmpty()
+            && !mSteamInputFluids.isEmpty()) {
+            updateHatchTexture();
+            tierMachine = 2;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public int getMaxParallelRecipes() {
+        return tierMachine == 1 ? 8 : 16;
+    }
+
+    @Override
+    public RecipeMap<?> getRecipeMap() {
+        return RecipeMaps.hammerRecipes;
+    }
+
+    @SideOnly(Side.CLIENT)
+    @Override
+    protected ResourceLocation getActivitySoundLoop() {
+        return SoundResource.RANDOM_ANVIL_USE.resourceLocation;
+    }
+
+    @Override
+    protected ProcessingLogic createProcessingLogic() {
+        return new ProcessingLogic() {
+
+            @Override
+            @Nonnull
+            protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe) {
+                return GT_OverclockCalculator.ofNoOverclock(recipe)
+                    .setEUtDiscount(1.33F)
+                    .setSpeedBoost(1.5F);
+            }
+        }.setMaxParallelSupplier(this::getMaxParallelRecipes);
+    }
+
+    @Override
+    protected GT_Multiblock_Tooltip_Builder createTooltip() {
+        GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType(getMachineType())
+            .addInfo("Controller Block for the Steam Forge Hammer")
+            .addInfo("Runs recipes up to MV tier")
+            .addInfo("33.3% faster than a single block steam machine would run.")
+            .addInfo(
+                "On Tier 1, it uses only 66.6% of the steam/s required compared to what a single block steam machine would use.")
+            .addInfo("Processes up to 8 x Tier things at a time.")
+            .addSeparator()
+            .beginStructureBlock(6, 5, 5, false)
+            .addInputBus(EnumChatFormatting.GOLD + "1" + EnumChatFormatting.GRAY + " Any casing", 1)
+            .addOutputBus(EnumChatFormatting.GOLD + "1" + EnumChatFormatting.GRAY + " Any casing", 1)
+            .addStructureInfo(
+                EnumChatFormatting.WHITE + "Steam Input Hatch "
+                    + EnumChatFormatting.GOLD
+                    + "1"
+                    + EnumChatFormatting.GRAY
+                    + " Any casing")
+            .addStructureInfo("")
+            .addStructureInfo(EnumChatFormatting.BLUE + "Tier " + EnumChatFormatting.DARK_PURPLE + 1)
+            .addStructureInfo(EnumChatFormatting.GOLD + "35-39x" + EnumChatFormatting.GRAY + " Bronze Plated Bricks")
+            .addStructureInfo(EnumChatFormatting.GOLD + "2x" + EnumChatFormatting.GRAY + " Bronze Pipe Casing")
+            .addStructureInfo(EnumChatFormatting.GOLD + "2x" + EnumChatFormatting.GRAY + " Iron Block")
+            .addStructureInfo("")
+            .addStructureInfo(EnumChatFormatting.BLUE + "Tier " + EnumChatFormatting.DARK_PURPLE + 2)
+            .addStructureInfo(
+                EnumChatFormatting.GOLD + "35-39x" + EnumChatFormatting.GRAY + " Solid Steel Machine Casing")
+            .addStructureInfo(EnumChatFormatting.GOLD + "2x" + EnumChatFormatting.GRAY + " Steel Pipe Casing")
+            .addStructureInfo(
+                EnumChatFormatting.GOLD + "2x"
+                    + EnumChatFormatting.GRAY
+                    + " Steel Block"
+                    + EnumChatFormatting.RED
+                    + " from GregTech")
+            .addStructureInfo("")
+            .toolTipFinisher(AuthorEvgenWarGold);
+        return tt;
+    }
+
+    @Override
+    public String[] getInfoData() {
+        ArrayList<String> info = new ArrayList<>(Arrays.asList(super.getInfoData()));
+        info.add("Machine Tier: " + EnumChatFormatting.YELLOW + tierMachine);
+        info.add("Parallel: " + EnumChatFormatting.YELLOW + getMaxParallelRecipes());
+        return info.toArray(new String[0]);
+    }
+
+    @Override
+    public void getWailaBody(ItemStack itemStack, List<String> currenttip, IWailaDataAccessor accessor,
+        IWailaConfigHandler config) {
+        super.getWailaBody(itemStack, currenttip, accessor, config);
+        NBTTagCompound tag = accessor.getNBTData();
+
+        currenttip.add(
+            StatCollector.translateToLocal("GTPP.machines.tier") + ": "
+                + EnumChatFormatting.YELLOW
+                + tag.getInteger("tierMachine")
+                + EnumChatFormatting.RESET);
+        currenttip.add(
+            StatCollector.translateToLocal("GT5U.multiblock.curparallelism") + ": "
+                + EnumChatFormatting.BLUE
+                + tag.getInteger("parallel")
+                + EnumChatFormatting.RESET);
+    }
+
+    @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);
+        tag.setInteger("tierMachine", tierMachine);
+        tag.setInteger("parallel", getMaxParallelRecipes());
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        super.saveNBTData(aNBT);
+        aNBT.setInteger("tierMachine", tierMachine);
+    }
+
+    @Override
+    public void loadNBTData(final NBTTagCompound aNBT) {
+        super.loadNBTData(aNBT);
+        tierMachine = aNBT.getInteger("tierMachine");
+    }
+
+}