WDMla compat

dependencies.gradle

@@ -7,7 +7,7 @@ dependencies {
     implementation("com.github.GTNewHorizons:NotEnoughItems:2.7.49-GTNH:dev")
     compileOnlyApi("curse.maven:cofh-core-69162:2388751")
     compileOnly("com.github.GTNewHorizons:inventory-tweaks:1.7.1:api")
-    compileOnly("com.github.GTNewHorizons:waila:1.8.7:api")
+    compileOnly("com.github.GTNewHorizons:WDMla:2.5.0:dev")
     compileOnly("com.github.GTNewHorizons:Battlegear2:1.4.3:api")
     compileOnly("curse.maven:minefactory-reloaded-66672:2366150")
     compileOnly("curse.maven:zelda-sword-skills-220540:2384889")

src/main/java/tconstruct/plugins/waila/TinkerWaila.java

@@ -1,5 +1,6 @@
 package tconstruct.plugins.waila;
 
+import cpw.mods.fml.common.Loader;
 import cpw.mods.fml.common.event.FMLInitializationEvent;
 import cpw.mods.fml.common.event.FMLInterModComms;
 import cpw.mods.fml.common.registry.GameRegistry.ObjectHolder;
@@ -17,6 +18,10 @@ public class TinkerWaila {
 
     @Handler
     public void init(FMLInitializationEvent event) {
+        if (Loader.isModLoaded("wdmla")) {
+            return;
+        }
+
         TConstruct.logger.info("Waila detected. Registering TConstruct tank blocks with Waila registry.");
         FMLInterModComms.sendMessage("Waila", "register", "tconstruct.plugins.waila.WailaRegistrar.wailaCallback");
     }

src/main/java/tconstruct/plugins/wdmla/DryingRackProvider.java

@@ -0,0 +1,69 @@
+package tconstruct.plugins.wdmla;
+
+import java.util.Arrays;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ResourceLocation;
+
+import com.gtnewhorizons.wdmla.api.accessor.BlockAccessor;
+import com.gtnewhorizons.wdmla.api.provider.IBlockComponentProvider;
+import com.gtnewhorizons.wdmla.api.provider.IServerDataProvider;
+import com.gtnewhorizons.wdmla.api.ui.IComponent;
+import com.gtnewhorizons.wdmla.api.ui.ITooltip;
+import com.gtnewhorizons.wdmla.impl.ui.ThemeHelper;
+
+import tconstruct.blocks.logic.DryingRackLogic;
+import tconstruct.library.crafting.DryingRackRecipes;
+
+public enum DryingRackProvider implements IBlockComponentProvider, IServerDataProvider<BlockAccessor> {
+
+    INSTANCE;
+
+    @Override
+    public void appendTooltip(ITooltip tooltip, BlockAccessor accessor) {
+        ItemStack content = ItemStack.loadItemStackFromNBT(accessor.getServerData());
+        if (content != null) {
+            int time = accessor.getServerData().getInteger("Time");
+            int maxTime = accessor.getServerData().getInteger("MaxTime");
+            if (time != 0 && maxTime != 0) {
+                ItemStack result = DryingRackRecipes.getDryingResult(content);
+                if (result != null) {
+                    result.stackSize = 0;
+                }
+                IComponent progressComponent = ThemeHelper.INSTANCE.furnaceLikeProgress(
+                        Arrays.asList(content),
+                        Arrays.asList(result),
+                        time,
+                        maxTime,
+                        accessor.showDetails());
+                if (progressComponent != null) {
+                    tooltip.child(progressComponent);
+                }
+            } else {
+                tooltip.child(ThemeHelper.INSTANCE.itemStackFullLine(content));
+            }
+        }
+    }
+
+    @Override
+    public void appendServerData(NBTTagCompound data, BlockAccessor accessor) {
+        if (accessor.getTarget() instanceof DryingRackLogic tileEntity) {
+            ItemStack stack = tileEntity.getStackInSlot(0);
+            if (stack == null) {
+                return;
+            }
+            NBTTagCompound rawData = new NBTTagCompound();
+            tileEntity.writeToNBT(rawData);
+            stack = stack.copy();
+            stack.writeToNBT(data);
+            data.setInteger("MaxTime", rawData.getInteger("MaxTime"));
+            data.setInteger("Time", rawData.getInteger("Time"));
+        }
+    }
+
+    @Override
+    public ResourceLocation getUid() {
+        return TinkerWDMla.TiC("drying_rack");
+    }
+}

src/main/java/tconstruct/plugins/wdmla/FurnaceSlabProvider.java

@@ -0,0 +1,81 @@
+package tconstruct.plugins.wdmla;
+
+import java.util.Arrays;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.FurnaceRecipes;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.util.ResourceLocation;
+
+import com.gtnewhorizons.wdmla.api.accessor.BlockAccessor;
+import com.gtnewhorizons.wdmla.api.provider.IBlockComponentProvider;
+import com.gtnewhorizons.wdmla.api.provider.IServerDataProvider;
+import com.gtnewhorizons.wdmla.api.ui.IComponent;
+import com.gtnewhorizons.wdmla.api.ui.ITooltip;
+import com.gtnewhorizons.wdmla.impl.ui.ThemeHelper;
+
+import tconstruct.tools.logic.FurnaceLogic;
+
+public enum FurnaceSlabProvider implements IBlockComponentProvider, IServerDataProvider<BlockAccessor> {
+
+    INSTANCE;
+
+    @Override
+    public void appendTooltip(ITooltip tooltip, BlockAccessor accessor) {
+        if (accessor.getTileEntity() instanceof FurnaceLogic) {
+            int cookTime = accessor.getServerData().getShort("Progress");
+            int maxCookTime = accessor.getServerData().getShort("MaxProgress");
+
+            ItemStack[] items = new ItemStack[3];
+            NBTTagList itemsTag = accessor.getServerData().getTagList("Items", 10);
+
+            boolean allEmpty = true;
+            for (int i = 0; i < itemsTag.tagCount(); i++) {
+                NBTTagCompound itemTag = itemsTag.getCompoundTagAt(i);
+                byte slot = itemTag.getByte("Slot");
+
+                if (slot >= 0 && slot < items.length) {
+                    items[slot] = ItemStack.loadItemStackFromNBT(itemTag);
+                    if (items[slot] != null) {
+                        allEmpty = false;
+                    }
+                }
+            }
+
+            if (items[0] != null && items[2] == null) {
+                ItemStack resultStack = FurnaceRecipes.smelting().getSmeltingResult(items[0]);
+                if (resultStack != null) {
+                    items[2] = resultStack.copy();
+                    items[2].stackSize = 0;
+                }
+            }
+
+            if (!allEmpty) {
+                IComponent progressComponent = ThemeHelper.INSTANCE.furnaceLikeProgress(
+                        Arrays.asList(items[0], items[1]),
+                        Arrays.asList(items[2]),
+                        cookTime,
+                        maxCookTime,
+                        accessor.showDetails());
+                if (progressComponent != null) {
+                    tooltip.child(progressComponent);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void appendServerData(NBTTagCompound data, BlockAccessor accessor) {
+        if (accessor.getTileEntity() instanceof FurnaceLogic logic) {
+            logic.writeToNBT(data);
+            data.setInteger("Progress", logic.progress);
+            data.setInteger("MaxProgress", logic.fuelScale);
+        }
+    }
+
+    @Override
+    public ResourceLocation getUid() {
+        return TinkerWDMla.TiC("furnace_slab");
+    }
+}

src/main/java/tconstruct/plugins/wdmla/LandmineHeaderProvider.java

@@ -0,0 +1,31 @@
+package tconstruct.plugins.wdmla;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+import com.gtnewhorizons.wdmla.api.accessor.BlockAccessor;
+import com.gtnewhorizons.wdmla.api.provider.IBlockComponentProvider;
+import com.gtnewhorizons.wdmla.api.ui.ITooltip;
+import com.gtnewhorizons.wdmla.impl.ui.ThemeHelper;
+
+import tconstruct.mechworks.logic.TileEntityLandmine;
+
+public enum LandmineHeaderProvider implements IBlockComponentProvider {
+
+    INSTANCE;
+
+    @Override
+    public void appendTooltip(ITooltip tooltip, BlockAccessor accessor) {
+        if (accessor.getTileEntity() instanceof TileEntityLandmine landmine) {
+            ItemStack cover = landmine.getStackInSlot(3);
+            if (cover != null) {
+                ThemeHelper.INSTANCE.overrideTooltipHeader(tooltip, cover);
+            }
+        }
+    }
+
+    @Override
+    public ResourceLocation getUid() {
+        return TinkerWDMla.TiC("landmine_header");
+    }
+}

src/main/java/tconstruct/plugins/wdmla/SearedBlockProgressProvider.java

@@ -0,0 +1,55 @@
+package tconstruct.plugins.wdmla;
+
+import java.util.Arrays;
+import java.util.List;
+
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.StatCollector;
+
+import com.gtnewhorizons.wdmla.api.accessor.Accessor;
+import com.gtnewhorizons.wdmla.api.provider.IClientExtensionProvider;
+import com.gtnewhorizons.wdmla.api.provider.IServerExtensionProvider;
+import com.gtnewhorizons.wdmla.api.view.ClientViewGroup;
+import com.gtnewhorizons.wdmla.api.view.ProgressView;
+import com.gtnewhorizons.wdmla.api.view.ViewGroup;
+import com.gtnewhorizons.wdmla.impl.ui.ThemeHelper;
+import com.gtnewhorizons.wdmla.util.FormatUtil;
+
+import tconstruct.smeltery.logic.CastingBlockLogic;
+
+public enum SearedBlockProgressProvider implements IServerExtensionProvider<ProgressView.Data>,
+        IClientExtensionProvider<ProgressView.Data, ProgressView> {
+
+    INSTANCE;
+
+    @Override
+    public ResourceLocation getUid() {
+        return TinkerWDMla.TiC("seared_blocks");
+    }
+
+    @Override
+    public List<ClientViewGroup<ProgressView>> getClientGroups(Accessor accessor,
+            List<ViewGroup<ProgressView.Data>> groups) {
+        return ClientViewGroup.map(groups, ProgressView::read, (group, clientGroup) -> {
+            ProgressView view = clientGroup.views.get(0);
+            view.description = ThemeHelper.INSTANCE.value(
+                    StatCollector.translateToLocal("hud.msg.wdmla.progress"),
+                    FormatUtil.PERCENTAGE_STANDARD.format((float) view.progress / 100));
+            view.hasScale = true;
+        });
+    }
+
+    @Override
+    public List<ViewGroup<ProgressView.Data>> getGroups(Accessor accessor) {
+        if (accessor.getTarget() instanceof CastingBlockLogic castingBlockLogic) {
+            int progress = castingBlockLogic.getProgress();
+            if (progress == 0) {
+                return null;
+            }
+            ProgressView.Data progressData = new ProgressView.Data(progress, 100);
+            ViewGroup<ProgressView.Data> group = new ViewGroup<>(Arrays.asList(progressData));
+            return Arrays.asList(group);
+        }
+        return null;
+    }
+}

src/main/java/tconstruct/plugins/wdmla/SmelteryFluidProvider.java

@@ -0,0 +1,51 @@
+package tconstruct.plugins.wdmla;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import net.minecraft.util.ResourceLocation;
+
+import com.gtnewhorizons.wdmla.api.accessor.Accessor;
+import com.gtnewhorizons.wdmla.api.provider.IClientExtensionProvider;
+import com.gtnewhorizons.wdmla.api.provider.IServerExtensionProvider;
+import com.gtnewhorizons.wdmla.api.view.ClientViewGroup;
+import com.gtnewhorizons.wdmla.api.view.FluidView;
+import com.gtnewhorizons.wdmla.api.view.ViewGroup;
+
+import tconstruct.smeltery.logic.SmelteryLogic;
+
+public enum SmelteryFluidProvider
+        implements IServerExtensionProvider<FluidView.Data>, IClientExtensionProvider<FluidView.Data, FluidView> {
+
+    INSTANCE;
+
+    private static final int FLUID_LIMIT = 4;
+
+    @Override
+    public List<ClientViewGroup<FluidView>> getClientGroups(Accessor accessor, List<ViewGroup<FluidView.Data>> groups) {
+        return ClientViewGroup.map(groups, FluidView::readDefault, (group, clientGroup) -> {});
+    }
+
+    @Override
+    public List<ViewGroup<FluidView.Data>> getGroups(Accessor accessor) {
+        if (!(accessor.getTarget() instanceof SmelteryLogic smelteryLogic)) {
+            return null;
+        }
+        if (smelteryLogic.moltenMetal.isEmpty()) {
+            return Arrays.asList(new ViewGroup<>(Arrays.asList(new FluidView.Data(null, smelteryLogic.maxLiquid))));
+        }
+        List<ViewGroup<FluidView.Data>> tanks = smelteryLogic.moltenMetal.stream().limit(FLUID_LIMIT).map(
+                fluidStack -> new ViewGroup<>(Arrays.asList(new FluidView.Data(fluidStack, smelteryLogic.maxLiquid))))
+                .collect(Collectors.toList());
+        if (smelteryLogic.moltenMetal.size() > FLUID_LIMIT) {
+            tanks.get(FLUID_LIMIT - 1).getExtraData().setInteger("+", smelteryLogic.moltenMetal.size() - tanks.size());
+        }
+        return tanks;
+    }
+
+    @Override
+    public ResourceLocation getUid() {
+        return TinkerWDMla.TiC("smeltery_fluid");
+    }
+}

src/main/java/tconstruct/plugins/wdmla/SmelteryStatusProvider.java

@@ -0,0 +1,58 @@
+package tconstruct.plugins.wdmla;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ResourceLocation;
+
+import com.gtnewhorizons.wdmla.api.accessor.BlockAccessor;
+import com.gtnewhorizons.wdmla.api.provider.IBlockComponentProvider;
+import com.gtnewhorizons.wdmla.api.provider.IServerDataProvider;
+import com.gtnewhorizons.wdmla.api.ui.ITooltip;
+import com.gtnewhorizons.wdmla.impl.ui.StatusHelper;
+
+import tconstruct.smeltery.logic.SmelteryLogic;
+
+public enum SmelteryStatusProvider implements IBlockComponentProvider, IServerDataProvider<BlockAccessor> {
+
+    INSTANCE;
+
+    @Override
+    public void appendTooltip(ITooltip tooltip, BlockAccessor accessor) {
+        if (accessor.getServerData().hasKey("State")) {
+            int status = accessor.getServerData().getByte("State");
+            switch (status) {
+                case 1:
+                    tooltip.child(StatusHelper.INSTANCE.insufficientFuel());
+                    break;
+                case 2:
+                    tooltip.child(StatusHelper.INSTANCE.idle());
+                    break;
+                case 3:
+                    tooltip.child(StatusHelper.INSTANCE.runningFine());
+                    break;
+                default:
+                    tooltip.child(StatusHelper.INSTANCE.structureIncomplete());
+                    break;
+            }
+        }
+    }
+
+    @Override
+    public void appendServerData(NBTTagCompound data, BlockAccessor accessor) {
+        if (accessor.getTileEntity() instanceof SmelteryLogic logic) {
+            if (!logic.validStructure) {
+                data.setByte("State", (byte) 0);
+            } else if (!logic.hasFuel()) {
+                data.setByte("State", (byte) 1);
+            } else if (!logic.isInUse()) {
+                data.setByte("State", (byte) 2);
+            } else {
+                data.setByte("State", (byte) 3);
+            }
+        }
+    }
+
+    @Override
+    public ResourceLocation getUid() {
+        return TinkerWDMla.TiC("smeltery_status");
+    }
+}