15366166327

Committed 31 May 2025 05:58PM UTC coverage: 44.766% (-0.5%) from 45.303%

Build # 15366166327

Build Type

push

github

Committed by

rubensworks

Commit Message

Bump mod version

Run Details

2565 of 8515 branches covered (30.12%)

Branch coverage included in aggregate %.

11734 of 23427 relevant lines covered (50.09%)

2.38 hits per line

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

6.58

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

package org.cyclops.integrateddynamics.core.logicprogrammer;

import lombok.Getter;
import net.minecraft.client.gui.screens.Screen;
import net.minecraft.network.chat.Component;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.inventory.AbstractContainerMenu;
import net.minecraft.world.inventory.ClickType;
import net.minecraft.world.inventory.Slot;
import net.minecraft.world.item.ItemStack;
import net.neoforged.api.distmarker.Dist;
import net.neoforged.api.distmarker.OnlyIn;
import org.cyclops.cyclopscore.helper.L10NHelpers;
import org.cyclops.integrateddynamics.IntegratedDynamics;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.api.client.gui.subgui.IGuiInputElementValueType;
import org.cyclops.integrateddynamics.api.client.gui.subgui.ISubGuiBox;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
import org.cyclops.integrateddynamics.api.item.IValueTypeVariableFacade;
import org.cyclops.integrateddynamics.api.item.IVariableFacade;
import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandlerRegistry;
import org.cyclops.integrateddynamics.api.logicprogrammer.IConfigRenderPattern;
import org.cyclops.integrateddynamics.api.logicprogrammer.ILogicProgrammerElementType;
import org.cyclops.integrateddynamics.api.logicprogrammer.IValueTypeLogicProgrammerElement;
import org.cyclops.integrateddynamics.client.gui.container.ContainerScreenLogicProgrammerBase;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueHelpers;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
import org.cyclops.integrateddynamics.core.item.ValueTypeVariableFacade;
import org.cyclops.integrateddynamics.inventory.container.ContainerLogicProgrammerBase;

import javax.annotation.Nullable;
import java.util.List;

/**
 * Element for value type.
 * @author rubensworks
 */
public abstract class ValueTypeLPElementBase implements IValueTypeLogicProgrammerElement<ISubGuiBox, ContainerScreenLogicProgrammerBase, ContainerLogicProgrammerBase> {

    @Getter
    private final IValueType<?> valueType;

    public ValueTypeLPElementBase(IValueType<?> valueType) {
        this.valueType = valueType;
    }

    @Nullable
    @Override
    public <G2 extends Screen, C2 extends AbstractContainerMenu> IGuiInputElementValueType<?, G2, C2> createInnerGuiElement() {
        return null;
    }

    @Nullable
    public IGuiInputElementValueType<?, ContainerScreenLogicProgrammerBase, ContainerLogicProgrammerBase> getInnerGuiElement() {
        return null;
    }

    @Override
    public void loadTooltip(List<Component> lines) {
        getValueType().loadTooltip(lines, true, null);
    }

    @Override
    public ILogicProgrammerElementType getType() {
        return LogicProgrammerElementTypes.VALUETYPE;
    }

    @Override
    public String getMatchString() {
        return getName().getString().toLowerCase();
    }

    @Override
    public boolean matchesInput(IValueType<?> valueType) {
        return false;
    }

    @Override
    public boolean matchesOutput(IValueType<?> valueType) {
        return ValueHelpers.correspondsTo(valueType, valueType);
    }

    @Override
    public Component getName() {
        return Component.translatable(valueType.getTranslationKey());
    }

    @Override
    public IConfigRenderPattern getRenderPattern() {
        return IConfigRenderPattern.NONE;
    }

    @Override
    public void onInputSlotUpdated(Player player, int slotId, ItemStack itemStack) {

    }

    @Override
    public boolean isFor(IVariableFacade variableFacade) {
        if (variableFacade instanceof IValueTypeVariableFacade) {
            IValueTypeVariableFacade valueTypeFacade = (IValueTypeVariableFacade) variableFacade;
            if (valueTypeFacade.isValid()) {
                return getValueType() == valueTypeFacade.getValueType();
            }
        }
        return false;
    }

    @Override
    public boolean canWriteElementPre() {
        return true;
    }

    @Override
    public ItemStack writeElement(Player player, ItemStack itemStack) {
        IVariableFacadeHandlerRegistry registry = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class);
        return registry.writeVariableFacadeItem(!player.level().isClientSide(), itemStack, ValueTypes.REGISTRY,
                new ValueTypeVariableFacadeFactory(getValueType(), getValue()), player.level(), player, RegistryEntries.BLOCK_LOGIC_PROGRAMMER.get().defaultBlockState());
    }

    @Override
    public void loadElement(IVariableFacade variableFacade) {
        if (variableFacade instanceof IValueTypeVariableFacade valueTypeVariableFacade) {
            setValue(valueTypeVariableFacade.getValue());
        }
    }

    @Override
    public boolean canCurrentlyReadFromOtherItem() {
        return true;
    }

    @Override
    public void activate() {

    }

    @Override
    public void deactivate() {

    }

    @Override
    public int getColor() {
        return valueType.getDisplayColor();
    }

    @Override
    public String getSymbol() {
        return L10NHelpers.localize(valueType.getTranslationKey());
    }

    @Override
    public boolean isItemValidForSlot(int slotId, ItemStack itemStack) {
        return itemStack.getItem() == RegistryEntries.ITEM_VARIABLE.get();
    }

    @Override
    public boolean slotClick(int slotId, Slot slot, int mouseButton, ClickType clickType, Player player) {
        return false;
    }

    @Override
    public int getItemStackSizeLimit() {
        return 1;
    }

    @Override
    @OnlyIn(Dist.CLIENT)
    public boolean isFocused(ISubGuiBox subGui) {
        if (subGui instanceof ValueTypeStringLPElementRenderPattern) {
            return ((ValueTypeStringLPElementRenderPattern) subGui).getTextField().isFocused();
        }
        return false;
    }

    @Override
    @OnlyIn(Dist.CLIENT)
    public void setFocused(ISubGuiBox subGui, boolean focused) {
        if (subGui instanceof ValueTypeStringLPElementRenderPattern) {
            ((ValueTypeStringLPElementRenderPattern) subGui).getTextField().setFocused(focused);
        }
    }

    @Override
    @OnlyIn(Dist.CLIENT)
    public abstract ISubGuiBox createSubGui(int baseX, int baseY, int maxWidth, int maxHeight,
                                            ContainerScreenLogicProgrammerBase gui, ContainerLogicProgrammerBase container);

    @Override
    public void setValue(IValue value) {
        if (getInnerGuiElement() != null) {
            getInnerGuiElement().setValue(value);
        }
    }

    @Override
    @OnlyIn(Dist.CLIENT)
    public void setValueInGui(ISubGuiBox subGui) {
        if (getInnerGuiElement() != null) {
            ((IGuiInputElementValueType) getInnerGuiElement()).setValueInGui(subGui, true);
        }
    }

    @Override
    public void setValueInContainer(ContainerLogicProgrammerBase container) {

    }

    public static class ValueTypeVariableFacadeFactory implements IVariableFacadeHandlerRegistry.IVariableFacadeFactory<IValueTypeVariableFacade> {

        private final IValueType valueType;
        private final IValue value;

        public ValueTypeVariableFacadeFactory(IValueType valueType, IValue value) {
            this.valueType = valueType;
            this.value = value;
        }

        public ValueTypeVariableFacadeFactory(IValue value) {
            this(value.getType(), value);
        }

        @Override
        public IValueTypeVariableFacade create(boolean generateId) {
            return new ValueTypeVariableFacade(generateId, valueType, value);
        }

        @Override
        public IValueTypeVariableFacade create(int id) {
            return new ValueTypeVariableFacade(id, valueType, value);
        }
    }

}

1	package org.cyclops.integrateddynamics.core.logicprogrammer;
2
3	import lombok.Getter;
4	import net.minecraft.client.gui.screens.Screen;
5	import net.minecraft.network.chat.Component;
6	import net.minecraft.world.entity.player.Player;
7	import net.minecraft.world.inventory.AbstractContainerMenu;
8	import net.minecraft.world.inventory.ClickType;
9	import net.minecraft.world.inventory.Slot;
10	import net.minecraft.world.item.ItemStack;
11	import net.neoforged.api.distmarker.Dist;
12	import net.neoforged.api.distmarker.OnlyIn;
13	import org.cyclops.cyclopscore.helper.L10NHelpers;
14	import org.cyclops.integrateddynamics.IntegratedDynamics;
15	import org.cyclops.integrateddynamics.RegistryEntries;
16	import org.cyclops.integrateddynamics.api.client.gui.subgui.IGuiInputElementValueType;
17	import org.cyclops.integrateddynamics.api.client.gui.subgui.ISubGuiBox;
18	import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
19	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
20	import org.cyclops.integrateddynamics.api.item.IValueTypeVariableFacade;
21	import org.cyclops.integrateddynamics.api.item.IVariableFacade;
22	import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandlerRegistry;
23	import org.cyclops.integrateddynamics.api.logicprogrammer.IConfigRenderPattern;
24	import org.cyclops.integrateddynamics.api.logicprogrammer.ILogicProgrammerElementType;
25	import org.cyclops.integrateddynamics.api.logicprogrammer.IValueTypeLogicProgrammerElement;
26	import org.cyclops.integrateddynamics.client.gui.container.ContainerScreenLogicProgrammerBase;
27	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueHelpers;
28	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
29	import org.cyclops.integrateddynamics.core.item.ValueTypeVariableFacade;
30	import org.cyclops.integrateddynamics.inventory.container.ContainerLogicProgrammerBase;
31
32	import javax.annotation.Nullable;
33	import java.util.List;
34
35	/**
36	* Element for value type.
37	* @author rubensworks
38	*/
39	public abstract class ValueTypeLPElementBase implements IValueTypeLogicProgrammerElement<ISubGuiBox, ContainerScreenLogicProgrammerBase, ContainerLogicProgrammerBase> {
40
41	@Getter	×
42	private final IValueType<?> valueType;
43
44	public ValueTypeLPElementBase(IValueType<?> valueType) {	×
45	this.valueType = valueType;	×
46	}	×
47
48	@Nullable
49	@Override
50	public <G2 extends Screen, C2 extends AbstractContainerMenu> IGuiInputElementValueType<?, G2, C2> createInnerGuiElement() {
51	return null;	×
52	}
53
54	@Nullable
55	public IGuiInputElementValueType<?, ContainerScreenLogicProgrammerBase, ContainerLogicProgrammerBase> getInnerGuiElement() {
56	return null;	×
57	}
58
59	@Override
60	public void loadTooltip(List<Component> lines) {
61	getValueType().loadTooltip(lines, true, null);	×
62	}	×
63
64	@Override
65	public ILogicProgrammerElementType getType() {
66	return LogicProgrammerElementTypes.VALUETYPE;	×
67	}
68
69	@Override
70	public String getMatchString() {
71	return getName().getString().toLowerCase();	×
72	}
73
74	@Override
75	public boolean matchesInput(IValueType<?> valueType) {
76	return false;	×
77	}
78
79	@Override
80	public boolean matchesOutput(IValueType<?> valueType) {
81	return ValueHelpers.correspondsTo(valueType, valueType);	×
82	}
83
84	@Override
85	public Component getName() {
86	return Component.translatable(valueType.getTranslationKey());	×
87	}
88
89	@Override
90	public IConfigRenderPattern getRenderPattern() {
91	return IConfigRenderPattern.NONE;	×
92	}
93
94	@Override
95	public void onInputSlotUpdated(Player player, int slotId, ItemStack itemStack) {
96
97	}	×
98
99	@Override
100	public boolean isFor(IVariableFacade variableFacade) {
101	if (variableFacade instanceof IValueTypeVariableFacade) {	×
102	IValueTypeVariableFacade valueTypeFacade = (IValueTypeVariableFacade) variableFacade;	×
103	if (valueTypeFacade.isValid()) {	×
104	return getValueType() == valueTypeFacade.getValueType();	×
105	}
106	}
107	return false;	×
108	}
109
110	@Override
111	public boolean canWriteElementPre() {
112	return true;	×
113	}
114
115	@Override
116	public ItemStack writeElement(Player player, ItemStack itemStack) {
117	IVariableFacadeHandlerRegistry registry = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class);	×
118	return registry.writeVariableFacadeItem(!player.level().isClientSide(), itemStack, ValueTypes.REGISTRY,	×
119	new ValueTypeVariableFacadeFactory(getValueType(), getValue()), player.level(), player, RegistryEntries.BLOCK_LOGIC_PROGRAMMER.get().defaultBlockState());	×
120	}
121
122	@Override
123	public void loadElement(IVariableFacade variableFacade) {
124	if (variableFacade instanceof IValueTypeVariableFacade valueTypeVariableFacade) {	×
125	setValue(valueTypeVariableFacade.getValue());	×
126	}
127	}	×
128
129	@Override
130	public boolean canCurrentlyReadFromOtherItem() {
131	return true;	×
132	}
133
134	@Override
135	public void activate() {
136
137	}	×
138
139	@Override
140	public void deactivate() {
141
142	}	×
143
144	@Override
145	public int getColor() {
146	return valueType.getDisplayColor();	×
147	}
148
149	@Override
150	public String getSymbol() {
151	return L10NHelpers.localize(valueType.getTranslationKey());	×
152	}
153
154	@Override
155	public boolean isItemValidForSlot(int slotId, ItemStack itemStack) {
156	return itemStack.getItem() == RegistryEntries.ITEM_VARIABLE.get();	×
157	}
158
159	@Override
160	public boolean slotClick(int slotId, Slot slot, int mouseButton, ClickType clickType, Player player) {
161	return false;	×
162	}
163
164	@Override
165	public int getItemStackSizeLimit() {
166	return 1;	×
167	}
168
169	@Override
170	@OnlyIn(Dist.CLIENT)
171	public boolean isFocused(ISubGuiBox subGui) {
172	if (subGui instanceof ValueTypeStringLPElementRenderPattern) {	×
173	return ((ValueTypeStringLPElementRenderPattern) subGui).getTextField().isFocused();	×
174	}
175	return false;	×
176	}
177
178	@Override
179	@OnlyIn(Dist.CLIENT)
180	public void setFocused(ISubGuiBox subGui, boolean focused) {
181	if (subGui instanceof ValueTypeStringLPElementRenderPattern) {	×
182	((ValueTypeStringLPElementRenderPattern) subGui).getTextField().setFocused(focused);	×
183	}
184	}	×
185
186	@Override
187	@OnlyIn(Dist.CLIENT)
188	public abstract ISubGuiBox createSubGui(int baseX, int baseY, int maxWidth, int maxHeight,
189	ContainerScreenLogicProgrammerBase gui, ContainerLogicProgrammerBase container);
190
191	@Override
192	public void setValue(IValue value) {
193	if (getInnerGuiElement() != null) {	×
194	getInnerGuiElement().setValue(value);	×
195	}
196	}	×
197
198	@Override
199	@OnlyIn(Dist.CLIENT)
200	public void setValueInGui(ISubGuiBox subGui) {
201	if (getInnerGuiElement() != null) {	×
202	((IGuiInputElementValueType) getInnerGuiElement()).setValueInGui(subGui, true);	×
203	}
204	}	×
205
206	@Override
207	public void setValueInContainer(ContainerLogicProgrammerBase container) {
208
209	}	×
210
211	public static class ValueTypeVariableFacadeFactory implements IVariableFacadeHandlerRegistry.IVariableFacadeFactory<IValueTypeVariableFacade> {
212
213	private final IValueType valueType;
214	private final IValue value;
215
216	public ValueTypeVariableFacadeFactory(IValueType valueType, IValue value) {	2✔
217	this.valueType = valueType;	3✔
218	this.value = value;	3✔
219	}	1✔
220
221	public ValueTypeVariableFacadeFactory(IValue value) {
222	this(value.getType(), value);	×
223	}	×
224
225	@Override
226	public IValueTypeVariableFacade create(boolean generateId) {
227	return new ValueTypeVariableFacade(generateId, valueType, value);	9✔
228	}
229
230	@Override
231	public IValueTypeVariableFacade create(int id) {
232	return new ValueTypeVariableFacade(id, valueType, value);	×
233	}
234	}
235
236	}

CyclopsMC / IntegratedDynamics / 15366166327

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