13216732296

Committed 08 Feb 2025 03:00PM UTC coverage: 38.585% (-0.004%) from 38.589%

Build # 13216732296

Build Type

push

github

Committed by

rubensworks

Commit Message

Bump mod version

Run Details

1948 of 8359 branches covered (23.3%)

Branch coverage included in aggregate %.

10108 of 22886 relevant lines covered (44.17%)

2.07 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/java/org/cyclops/integrateddynamics/core/logicprogrammer/ValueTypeRecipeLPElementPropertiesSubGui.java

package org.cyclops.integrateddynamics.core.logicprogrammer;

import com.google.common.collect.Sets;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Font;
import net.minecraft.client.gui.GuiGraphics;
import net.minecraft.client.renderer.texture.TextureManager;
import net.minecraft.core.Holder;
import net.minecraft.core.HolderSet;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.core.registries.Registries;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.MutableComponent;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.tags.TagKey;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.ItemStack;
import net.neoforged.api.distmarker.Dist;
import net.neoforged.api.distmarker.OnlyIn;
import org.cyclops.cyclopscore.client.gui.component.button.ButtonCheckbox;
import org.cyclops.cyclopscore.client.gui.component.button.ButtonImage;
import org.cyclops.cyclopscore.client.gui.image.Images;
import org.cyclops.cyclopscore.helper.GuiHelpers;
import org.cyclops.cyclopscore.helper.L10NHelpers;
import org.cyclops.integrateddynamics.client.gui.container.ContainerScreenLogicProgrammerBase;
import org.cyclops.integrateddynamics.core.client.gui.IDropdownEntry;
import org.cyclops.integrateddynamics.core.client.gui.WidgetTextFieldDropdown;
import org.cyclops.integrateddynamics.core.helper.L10NValues;
import org.cyclops.integrateddynamics.core.ingredient.ItemMatchProperties;
import org.cyclops.integrateddynamics.inventory.container.ContainerLogicProgrammerBase;

import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

/**
 * Selection panel for the list element value type.
 */
@OnlyIn(Dist.CLIENT)
class ValueTypeRecipeLPElementPropertiesSubGui extends RenderPattern<ValueTypeRecipeLPElement, ContainerScreenLogicProgrammerBase, ContainerLogicProgrammerBase> {

    private final int slotId;
    private ButtonCheckbox inputNbt;
    private ButtonCheckbox inputTags;
    private ButtonCheckbox inputReusable;
    private WidgetTextFieldDropdown<ResourceLocation> inputTagsDropdown;
    private ButtonImage inputSave;

    public ValueTypeRecipeLPElementPropertiesSubGui(ValueTypeRecipeLPElement element, int baseX, int baseY, int maxWidth, int maxHeight,
                                                    ContainerScreenLogicProgrammerBase gui, ContainerLogicProgrammerBase container,
                                                    int slotId) {
        super(element, baseX, baseY, maxWidth, maxHeight, gui, container);
        this.slotId = slotId;
    }

    @Override
    public void init(int guiLeft, int guiTop) {
        super.init(guiLeft, guiTop);

        this.inputNbt = new ButtonCheckbox(guiLeft + getX() + 2, guiTop + getY() + 2, 20, 10,
                Component.translatable(L10NValues.GUI_RECIPE_STRICTNBT), (entry) ->  {
            // Only allow one checkbox to be true at the same time
            if (this.inputNbt.isChecked()) {
                this.inputTags.setChecked(false);
            }
            saveGuiToState();
            loadStateToGui();
        });
        this.inputReusable = new ButtonCheckbox(guiLeft + getX() + 2, guiTop + getY() + 12, 20, 10,
                Component.translatable(L10NValues.GUI_RECIPE_REUSABLE), (entry) -> {
            saveGuiToState();
            loadStateToGui();
        });
        this.inputTags = new ButtonCheckbox(guiLeft + getX() + 2, guiTop + getY() + 22, 20, 10,
                Component.translatable(L10NValues.GUI_RECIPE_TAGVARIANTS), (entry) -> {
            // Only allow one checkbox to be true at the same time
            if (this.inputTags.isChecked()) {
                this.inputNbt.setChecked(false);
            }
            saveGuiToState();
            loadStateToGui();
            if (this.inputTags.isChecked()) {
                this.inputTagsDropdown.setFocused(true);
            }
        });
        this.inputTagsDropdown = new WidgetTextFieldDropdown<>(Minecraft.getInstance().font,
                guiLeft + getX() + 2, guiTop + getY() + 33,
                134, 14,
                Component.translatable("gui.cyclopscore.search"), true,
                Sets.newHashSet());
        this.inputTagsDropdown.setDropdownEntryListener((entry) -> saveGuiToState());
        this.inputTagsDropdown.setMaxLength(64);
        this.inputTagsDropdown.setDropdownSize(4);
        this.inputTagsDropdown.setBordered(false);
        this.inputTagsDropdown.setTextColor(16777215);
        this.inputTagsDropdown.setCanLoseFocus(true);
        this.inputSave = new ButtonImage(guiLeft + getX() + 116, guiTop + getY() + 72,
                Component.translatable("gui.integrateddynamics.button.save"),
                (button) -> {
            // If tag checkbox is checked, only allow exiting if a valid tag has been set
            if (!this.inputTags.isChecked() || this.inputTagsDropdown.getSelectedDropdownPossibility() != null) {
                element.lastGui.setRecipeSubGui();
            } else {
                this.inputTagsDropdown.setFocused(true);
            }
                }, Images.OK);

        // Load button states
        loadStateToGui();
        // Show dropdown if a tag was already set
        if (this.inputTags.isChecked()) {
            this.inputTagsDropdown.setFocused(true);
        }
    }

    public ItemStack getSlotContents() {
        return container.slots.get(slotId + ValueTypeRecipeLPElement.SLOT_OFFSET).getItem();
    }

    public ItemMatchProperties getSlotProperties() {
        return getElement().getInputStacks().get(slotId);
    }

    private Set<IDropdownEntry<ResourceLocation>> getDropdownEntries() {
        LinkedHashSet<IDropdownEntry<ResourceLocation>> set = Sets.newLinkedHashSet();
        if (getSlotContents().isEmpty()) {
            BuiltInRegistries.ITEM.getTagNames()
                    .forEach(registeredTag -> set.add(new DropdownEntry(registeredTag.location())));

        } else {
            getSlotContents().getItem().builtInRegistryHolder().tags()
                    .forEach(registeredTag -> set.add(new DropdownEntry(registeredTag.location())));
        }
        return set;
    }

    public void loadStateToGui() {
        ItemMatchProperties props = getSlotProperties();
        this.inputNbt.setChecked(props.isNbt());
        this.inputTags.setChecked(props.getItemTag() != null);
        this.inputReusable.setChecked(props.isReusable());
        this.inputTagsDropdown.setVisible(this.inputTags.isChecked());

        if (this.inputTags.isChecked()) {
            Set<IDropdownEntry<ResourceLocation>> dropdownEntries = getDropdownEntries();
            this.inputTagsDropdown.setPossibilities(dropdownEntries);
            if (props.getItemTag() != null) {
                this.inputTagsDropdown.selectPossibility(dropdownEntries.stream()
                        .filter(e -> e.getMatchString().equals(props.getItemTag()))
                        .findFirst()
                        .orElse(null));
            } else {
                if (!dropdownEntries.isEmpty()) {
                    this.inputTagsDropdown.selectPossibility(dropdownEntries.iterator().next());
                } else {
                    this.inputTagsDropdown.selectPossibility(null);
                }
            }
        } else {
            this.inputTagsDropdown.setValue("");
            this.inputTagsDropdown.setPossibilities(Collections.emptySet());
        }
    }

    public void saveGuiToState() {
        boolean nbt = this.inputNbt.isChecked();
        String tag = this.inputTags.isChecked() ? this.inputTagsDropdown.getValue() : null;
        getSlotProperties().setNbt(nbt);
        getSlotProperties().setItemTag(tag);
        getSlotProperties().setReusable(this.inputReusable.isChecked());
        element.sendSlotPropertiesToServer(slotId, getSlotProperties());
    }

    @Override
    protected boolean drawRenderPattern() {
        return false;
    }

    @Override
    public void renderBg(GuiGraphics guiGraphics, int guiLeft, int guiTop, TextureManager textureManager, Font fontRenderer, float partialTicks, int mouseX, int mouseY) {
        super.renderBg(guiGraphics, guiLeft, guiTop, textureManager, fontRenderer, partialTicks, mouseX, mouseY);

        drawSlot(guiGraphics, getX() + guiLeft + 116, getY() + guiTop + 2);

        this.inputNbt.render(guiGraphics, mouseX, mouseY, partialTicks);
        fontRenderer.drawInBatch(L10NHelpers.localize(L10NValues.GUI_RECIPE_STRICTNBT), guiLeft + getX() + 24, guiTop + getY() + 3, 0, false,
                guiGraphics.pose().last().pose(), guiGraphics.bufferSource(), Font.DisplayMode.NORMAL, 0, 15728880);
        this.inputReusable.render(guiGraphics, mouseX, mouseY, partialTicks);
        fontRenderer.drawInBatch(L10NHelpers.localize(L10NValues.GUI_RECIPE_REUSABLE), guiLeft + getX() + 24, guiTop + getY() + 13, 0, false,
                guiGraphics.pose().last().pose(), guiGraphics.bufferSource(), Font.DisplayMode.NORMAL, 0, 15728880);
        this.inputTags.render(guiGraphics, mouseX, mouseY, partialTicks);
        fontRenderer.drawInBatch(L10NHelpers.localize(L10NValues.GUI_RECIPE_TAGVARIANTS), guiLeft + getX() + 24, guiTop + getY() + 23, 0, false,
                guiGraphics.pose().last().pose(), guiGraphics.bufferSource(), Font.DisplayMode.NORMAL, 0, 15728880);
        this.inputSave.render(guiGraphics, mouseX, mouseY, partialTicks);
        this.inputTagsDropdown.render(guiGraphics, mouseX, mouseY, partialTicks);
    }

    @Override
    public void drawGuiContainerForegroundLayer(GuiGraphics guiGraphics, int guiLeft, int guiTop, TextureManager textureManager, Font fontRenderer, int mouseX, int mouseY) {
        super.drawGuiContainerForegroundLayer(guiGraphics, guiLeft, guiTop, textureManager, fontRenderer, mouseX, mouseY);

        if (this.inputTagsDropdown.isFocused()) {
            int i = this.inputTagsDropdown.getHoveredVisiblePossibility(mouseX, mouseY);
            if (i >= 0) {
                IDropdownEntry<ResourceLocation> hoveredPossibility = this.inputTagsDropdown.getVisiblePossibility(i);
                drawTagsTooltip(guiGraphics, hoveredPossibility, guiLeft, guiTop, mouseX + 10, mouseY - 20, 6, GuiHelpers.SLOT_SIZE);
            }
        }
    }

    protected void drawTagsTooltip(GuiGraphics guiGraphics, IDropdownEntry<ResourceLocation> hoveredPossibility, int guiLeft, int guiTop,
                                   int mouseX, int mouseY, int columns, int offset) {
        int x = mouseX - guiLeft;
        int y = mouseY - guiTop;
        List<Item> items = BuiltInRegistries.ITEM.getTag(TagKey.create(Registries.ITEM, hoveredPossibility.getValue()))
                .stream()
                .flatMap(HolderSet.ListBacked::stream)
                .map(Holder::value)
                .toList();

        // Draw background
        GuiHelpers.drawTooltipBackground(guiGraphics.pose(), x, y, Math.min(items.size(), columns) * offset,
                ((items.size() % columns == 0 ? 0 : 1) + (items.size() / columns)) * offset);

        // Draw item grid
        guiGraphics.pose().pushPose();
        guiGraphics.pose().translate(0, 0, 1000);
        int passed = 0;
        for (Item item : items) {
            guiGraphics.renderItem(new ItemStack(item), x, y);
            x += offset;
            if (passed++ % columns == columns - 1) {
                y += offset;
                x = mouseX - guiLeft;
            }
        }
        guiGraphics.pose().popPose();
    }

    @Override
    public boolean charTyped(char typedChar, int keyCode) {
        if (inputTagsDropdown.isFocused()) {
            if (inputTagsDropdown.charTyped(typedChar, keyCode)) {
                return true;
            }
        }
        return super.charTyped(typedChar, keyCode);
    }

    @Override
    public boolean keyPressed(int typedChar, int keyCode, int modifiers) {
        if (inputTagsDropdown.isFocused()) {
            inputTagsDropdown.keyPressed(typedChar, keyCode, modifiers);
            return true;
        }
        return super.keyPressed(typedChar, keyCode, modifiers);
    }

    @Override
    public boolean mouseClicked(double mouseX, double mouseY, int mouseButton) {
        return inputNbt.mouseClicked(mouseX, mouseY, mouseButton)
                || inputReusable.mouseClicked(mouseX, mouseY, mouseButton)
                || inputTags.mouseClicked(mouseX, mouseY, mouseButton)
                || inputTagsDropdown.mouseClicked(mouseX, mouseY, mouseButton)
                || inputSave.mouseClicked(mouseX, mouseY, mouseButton)
                || super.mouseClicked(mouseX, mouseY, mouseButton);
    }

    public static class DropdownEntry implements IDropdownEntry<ResourceLocation> {
        private final ResourceLocation tag;

        public DropdownEntry(ResourceLocation tag) {
            this.tag = tag;
        }

        @Override
        public String getMatchString() {
            return this.tag.toString();
        }

        @Override
        public MutableComponent getDisplayString() {
            return Component.literal(this.tag.toString());
        }

        @Override
        public List<MutableComponent> getTooltip() {
            return Collections.emptyList();
        }

        @Override
        public ResourceLocation getValue() {
            return this.tag;
        }
    }
}

1	package org.cyclops.integrateddynamics.core.logicprogrammer;
2
3	import com.google.common.collect.Sets;
4	import net.minecraft.client.Minecraft;
5	import net.minecraft.client.gui.Font;
6	import net.minecraft.client.gui.GuiGraphics;
7	import net.minecraft.client.renderer.texture.TextureManager;
8	import net.minecraft.core.Holder;
9	import net.minecraft.core.HolderSet;
10	import net.minecraft.core.registries.BuiltInRegistries;
11	import net.minecraft.core.registries.Registries;
12	import net.minecraft.network.chat.Component;
13	import net.minecraft.network.chat.MutableComponent;
14	import net.minecraft.resources.ResourceLocation;
15	import net.minecraft.tags.TagKey;
16	import net.minecraft.world.item.Item;
17	import net.minecraft.world.item.ItemStack;
18	import net.neoforged.api.distmarker.Dist;
19	import net.neoforged.api.distmarker.OnlyIn;
20	import org.cyclops.cyclopscore.client.gui.component.button.ButtonCheckbox;
21	import org.cyclops.cyclopscore.client.gui.component.button.ButtonImage;
22	import org.cyclops.cyclopscore.client.gui.image.Images;
23	import org.cyclops.cyclopscore.helper.GuiHelpers;
24	import org.cyclops.cyclopscore.helper.L10NHelpers;
25	import org.cyclops.integrateddynamics.client.gui.container.ContainerScreenLogicProgrammerBase;
26	import org.cyclops.integrateddynamics.core.client.gui.IDropdownEntry;
27	import org.cyclops.integrateddynamics.core.client.gui.WidgetTextFieldDropdown;
28	import org.cyclops.integrateddynamics.core.helper.L10NValues;
29	import org.cyclops.integrateddynamics.core.ingredient.ItemMatchProperties;
30	import org.cyclops.integrateddynamics.inventory.container.ContainerLogicProgrammerBase;
31
32	import java.util.Collections;
33	import java.util.LinkedHashSet;
34	import java.util.List;
35	import java.util.Set;
36
37	/**
38	* Selection panel for the list element value type.
39	*/
40	@OnlyIn(Dist.CLIENT)
41	class ValueTypeRecipeLPElementPropertiesSubGui extends RenderPattern<ValueTypeRecipeLPElement, ContainerScreenLogicProgrammerBase, ContainerLogicProgrammerBase> {
42
43	private final int slotId;
44	private ButtonCheckbox inputNbt;
45	private ButtonCheckbox inputTags;
46	private ButtonCheckbox inputReusable;
47	private WidgetTextFieldDropdown<ResourceLocation> inputTagsDropdown;
48	private ButtonImage inputSave;
49
50	public ValueTypeRecipeLPElementPropertiesSubGui(ValueTypeRecipeLPElement element, int baseX, int baseY, int maxWidth, int maxHeight,
51	ContainerScreenLogicProgrammerBase gui, ContainerLogicProgrammerBase container,
52	int slotId) {
53	super(element, baseX, baseY, maxWidth, maxHeight, gui, container);	×
54	this.slotId = slotId;	×
55	}	×
56
57	@Override
58	public void init(int guiLeft, int guiTop) {
59	super.init(guiLeft, guiTop);	×
60
61	this.inputNbt = new ButtonCheckbox(guiLeft + getX() + 2, guiTop + getY() + 2, 20, 10,	×
62	Component.translatable(L10NValues.GUI_RECIPE_STRICTNBT), (entry) -> {	×
63	// Only allow one checkbox to be true at the same time
64	if (this.inputNbt.isChecked()) {	×
65	this.inputTags.setChecked(false);	×
66	}
67	saveGuiToState();	×
68	loadStateToGui();	×
69	});	×
70	this.inputReusable = new ButtonCheckbox(guiLeft + getX() + 2, guiTop + getY() + 12, 20, 10,	×
71	Component.translatable(L10NValues.GUI_RECIPE_REUSABLE), (entry) -> {	×
72	saveGuiToState();	×
73	loadStateToGui();	×
74	});	×
75	this.inputTags = new ButtonCheckbox(guiLeft + getX() + 2, guiTop + getY() + 22, 20, 10,	×
76	Component.translatable(L10NValues.GUI_RECIPE_TAGVARIANTS), (entry) -> {	×
77	// Only allow one checkbox to be true at the same time
78	if (this.inputTags.isChecked()) {	×
79	this.inputNbt.setChecked(false);	×
80	}
81	saveGuiToState();	×
82	loadStateToGui();	×
83	if (this.inputTags.isChecked()) {	×
84	this.inputTagsDropdown.setFocused(true);	×
85	}
86	});	×
87	this.inputTagsDropdown = new WidgetTextFieldDropdown<>(Minecraft.getInstance().font,	×
88	guiLeft + getX() + 2, guiTop + getY() + 33,	×
89	134, 14,
90	Component.translatable("gui.cyclopscore.search"), true,	×
91	Sets.newHashSet());	×
92	this.inputTagsDropdown.setDropdownEntryListener((entry) -> saveGuiToState());	×
93	this.inputTagsDropdown.setMaxLength(64);	×
94	this.inputTagsDropdown.setDropdownSize(4);	×
95	this.inputTagsDropdown.setBordered(false);	×
96	this.inputTagsDropdown.setTextColor(16777215);	×
97	this.inputTagsDropdown.setCanLoseFocus(true);	×
98	this.inputSave = new ButtonImage(guiLeft + getX() + 116, guiTop + getY() + 72,	×
99	Component.translatable("gui.integrateddynamics.button.save"),	×
100	(button) -> {
101	// If tag checkbox is checked, only allow exiting if a valid tag has been set
102	if (!this.inputTags.isChecked() \|\| this.inputTagsDropdown.getSelectedDropdownPossibility() != null) {	×
103	element.lastGui.setRecipeSubGui();	×
104	} else {
105	this.inputTagsDropdown.setFocused(true);	×
106	}
107	}, Images.OK);	×
108
109	// Load button states
110	loadStateToGui();	×
111	// Show dropdown if a tag was already set
112	if (this.inputTags.isChecked()) {	×
113	this.inputTagsDropdown.setFocused(true);	×
114	}
115	}	×
116
117	public ItemStack getSlotContents() {
118	return container.slots.get(slotId + ValueTypeRecipeLPElement.SLOT_OFFSET).getItem();	×
119	}
120
121	public ItemMatchProperties getSlotProperties() {
122	return getElement().getInputStacks().get(slotId);	×
123	}
124
125	private Set<IDropdownEntry<ResourceLocation>> getDropdownEntries() {
126	LinkedHashSet<IDropdownEntry<ResourceLocation>> set = Sets.newLinkedHashSet();	×
127	if (getSlotContents().isEmpty()) {	×
128	BuiltInRegistries.ITEM.getTagNames()	×
129	.forEach(registeredTag -> set.add(new DropdownEntry(registeredTag.location())));	×
130
131	} else {
132	getSlotContents().getItem().builtInRegistryHolder().tags()	×
133	.forEach(registeredTag -> set.add(new DropdownEntry(registeredTag.location())));	×
134	}
135	return set;	×
136	}
137
138	public void loadStateToGui() {
139	ItemMatchProperties props = getSlotProperties();	×
140	this.inputNbt.setChecked(props.isNbt());	×
141	this.inputTags.setChecked(props.getItemTag() != null);	×
142	this.inputReusable.setChecked(props.isReusable());	×
143	this.inputTagsDropdown.setVisible(this.inputTags.isChecked());	×
144
145	if (this.inputTags.isChecked()) {	×
146	Set<IDropdownEntry<ResourceLocation>> dropdownEntries = getDropdownEntries();	×
147	this.inputTagsDropdown.setPossibilities(dropdownEntries);	×
148	if (props.getItemTag() != null) {	×
149	this.inputTagsDropdown.selectPossibility(dropdownEntries.stream()	×
150	.filter(e -> e.getMatchString().equals(props.getItemTag()))	×
151	.findFirst()	×
152	.orElse(null));	×
153	} else {
154	if (!dropdownEntries.isEmpty()) {	×
155	this.inputTagsDropdown.selectPossibility(dropdownEntries.iterator().next());	×
156	} else {
157	this.inputTagsDropdown.selectPossibility(null);	×
158	}
159	}
160	} else {	×
161	this.inputTagsDropdown.setValue("");	×
162	this.inputTagsDropdown.setPossibilities(Collections.emptySet());	×
163	}
164	}	×
165
166	public void saveGuiToState() {
167	boolean nbt = this.inputNbt.isChecked();	×
168	String tag = this.inputTags.isChecked() ? this.inputTagsDropdown.getValue() : null;	×
169	getSlotProperties().setNbt(nbt);	×
170	getSlotProperties().setItemTag(tag);	×
171	getSlotProperties().setReusable(this.inputReusable.isChecked());	×
172	element.sendSlotPropertiesToServer(slotId, getSlotProperties());	×
173	}	×
174
175	@Override
176	protected boolean drawRenderPattern() {
177	return false;	×
178	}
179
180	@Override
181	public void renderBg(GuiGraphics guiGraphics, int guiLeft, int guiTop, TextureManager textureManager, Font fontRenderer, float partialTicks, int mouseX, int mouseY) {
182	super.renderBg(guiGraphics, guiLeft, guiTop, textureManager, fontRenderer, partialTicks, mouseX, mouseY);	×
183
184	drawSlot(guiGraphics, getX() + guiLeft + 116, getY() + guiTop + 2);	×
185
186	this.inputNbt.render(guiGraphics, mouseX, mouseY, partialTicks);	×
187	fontRenderer.drawInBatch(L10NHelpers.localize(L10NValues.GUI_RECIPE_STRICTNBT), guiLeft + getX() + 24, guiTop + getY() + 3, 0, false,	×
188	guiGraphics.pose().last().pose(), guiGraphics.bufferSource(), Font.DisplayMode.NORMAL, 0, 15728880);	×
189	this.inputReusable.render(guiGraphics, mouseX, mouseY, partialTicks);	×
190	fontRenderer.drawInBatch(L10NHelpers.localize(L10NValues.GUI_RECIPE_REUSABLE), guiLeft + getX() + 24, guiTop + getY() + 13, 0, false,	×
191	guiGraphics.pose().last().pose(), guiGraphics.bufferSource(), Font.DisplayMode.NORMAL, 0, 15728880);	×
192	this.inputTags.render(guiGraphics, mouseX, mouseY, partialTicks);	×
193	fontRenderer.drawInBatch(L10NHelpers.localize(L10NValues.GUI_RECIPE_TAGVARIANTS), guiLeft + getX() + 24, guiTop + getY() + 23, 0, false,	×
194	guiGraphics.pose().last().pose(), guiGraphics.bufferSource(), Font.DisplayMode.NORMAL, 0, 15728880);	×
195	this.inputSave.render(guiGraphics, mouseX, mouseY, partialTicks);	×
196	this.inputTagsDropdown.render(guiGraphics, mouseX, mouseY, partialTicks);	×
197	}	×
198
199	@Override
200	public void drawGuiContainerForegroundLayer(GuiGraphics guiGraphics, int guiLeft, int guiTop, TextureManager textureManager, Font fontRenderer, int mouseX, int mouseY) {
201	super.drawGuiContainerForegroundLayer(guiGraphics, guiLeft, guiTop, textureManager, fontRenderer, mouseX, mouseY);	×
202
203	if (this.inputTagsDropdown.isFocused()) {	×
204	int i = this.inputTagsDropdown.getHoveredVisiblePossibility(mouseX, mouseY);	×
205	if (i >= 0) {	×
206	IDropdownEntry<ResourceLocation> hoveredPossibility = this.inputTagsDropdown.getVisiblePossibility(i);	×
207	drawTagsTooltip(guiGraphics, hoveredPossibility, guiLeft, guiTop, mouseX + 10, mouseY - 20, 6, GuiHelpers.SLOT_SIZE);	×
208	}
209	}
210	}	×
211
212	protected void drawTagsTooltip(GuiGraphics guiGraphics, IDropdownEntry<ResourceLocation> hoveredPossibility, int guiLeft, int guiTop,
213	int mouseX, int mouseY, int columns, int offset) {
214	int x = mouseX - guiLeft;	×
215	int y = mouseY - guiTop;	×
216	List<Item> items = BuiltInRegistries.ITEM.getTag(TagKey.create(Registries.ITEM, hoveredPossibility.getValue()))	×
217	.stream()	×
218	.flatMap(HolderSet.ListBacked::stream)	×
219	.map(Holder::value)	×
220	.toList();	×
221
222	// Draw background
223	GuiHelpers.drawTooltipBackground(guiGraphics.pose(), x, y, Math.min(items.size(), columns) * offset,	×
224	((items.size() % columns == 0 ? 0 : 1) + (items.size() / columns)) * offset);	×
225
226	// Draw item grid
227	guiGraphics.pose().pushPose();	×
228	guiGraphics.pose().translate(0, 0, 1000);	×
229	int passed = 0;	×
230	for (Item item : items) {	×
231	guiGraphics.renderItem(new ItemStack(item), x, y);	×
232	x += offset;	×
233	if (passed++ % columns == columns - 1) {	×
234	y += offset;	×
235	x = mouseX - guiLeft;	×
236	}
237	}	×
238	guiGraphics.pose().popPose();	×
239	}	×
240
241	@Override
242	public boolean charTyped(char typedChar, int keyCode) {
243	if (inputTagsDropdown.isFocused()) {	×
244	if (inputTagsDropdown.charTyped(typedChar, keyCode)) {	×
245	return true;	×
246	}
247	}
248	return super.charTyped(typedChar, keyCode);	×
249	}
250
251	@Override
252	public boolean keyPressed(int typedChar, int keyCode, int modifiers) {
253	if (inputTagsDropdown.isFocused()) {	×
254	inputTagsDropdown.keyPressed(typedChar, keyCode, modifiers);	×
255	return true;	×
256	}
257	return super.keyPressed(typedChar, keyCode, modifiers);	×
258	}
259
260	@Override
261	public boolean mouseClicked(double mouseX, double mouseY, int mouseButton) {
262	return inputNbt.mouseClicked(mouseX, mouseY, mouseButton)	×
263	\|\| inputReusable.mouseClicked(mouseX, mouseY, mouseButton)	×
264	\|\| inputTags.mouseClicked(mouseX, mouseY, mouseButton)	×
265	\|\| inputTagsDropdown.mouseClicked(mouseX, mouseY, mouseButton)	×
266	\|\| inputSave.mouseClicked(mouseX, mouseY, mouseButton)	×
267	\|\| super.mouseClicked(mouseX, mouseY, mouseButton);	×
268	}
269
270	public static class DropdownEntry implements IDropdownEntry<ResourceLocation> {
271	private final ResourceLocation tag;
272
273	public DropdownEntry(ResourceLocation tag) {	×
274	this.tag = tag;	×
275	}	×
276
277	@Override
278	public String getMatchString() {
279	return this.tag.toString();	×
280	}
281
282	@Override
283	public MutableComponent getDisplayString() {
284	return Component.literal(this.tag.toString());	×
285	}
286
287	@Override
288	public List<MutableComponent> getTooltip() {
289	return Collections.emptyList();	×
290	}
291
292	@Override
293	public ResourceLocation getValue() {
294	return this.tag;	×
295	}
296	}
297	}

CyclopsMC / IntegratedDynamics / 13216732296

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous