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

3.94

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

package org.cyclops.integrateddynamics.core.logicprogrammer;

import com.google.common.collect.Iterables;
import lombok.Data;
import net.minecraft.network.chat.Component;
import net.minecraft.world.entity.player.Player;
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.inventory.SimpleInventory;
import org.cyclops.integrateddynamics.IntegratedDynamics;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.api.evaluate.operator.IOperator;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeCategory;
import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
import org.cyclops.integrateddynamics.api.item.IOperatorVariableFacade;
import org.cyclops.integrateddynamics.api.item.IVariableFacade;
import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandler;
import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandlerRegistry;
import org.cyclops.integrateddynamics.api.logicprogrammer.IConfigRenderPattern;
import org.cyclops.integrateddynamics.api.logicprogrammer.ILogicProgrammerElement;
import org.cyclops.integrateddynamics.api.logicprogrammer.ILogicProgrammerElementType;
import org.cyclops.integrateddynamics.client.gui.container.ContainerScreenLogicProgrammerBase;
import org.cyclops.integrateddynamics.core.evaluate.operator.Operators;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueHelpers;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
import org.cyclops.integrateddynamics.core.item.OperatorVariableFacade;
import org.cyclops.integrateddynamics.core.item.ValueTypeVariableFacade;
import org.cyclops.integrateddynamics.inventory.container.ContainerLogicProgrammerBase;

import java.util.List;

/**
 * Element for operator.
 *
 * @author rubensworks
 */
@Data
public class OperatorLPElement implements ILogicProgrammerElement<RenderPattern, ContainerScreenLogicProgrammerBase, ContainerLogicProgrammerBase> {

    private final IOperator operator;
    private IVariableFacade[] inputVariables;
    private boolean focused = false;

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

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

    @Override
    public boolean matchesInput(IValueType valueType) {
        for (IValueType operatorIn : getOperator().getInputTypes()) {
            if(ValueHelpers.correspondsTo(operatorIn, valueType)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean matchesOutput(IValueType valueType) {
        return ValueHelpers.correspondsTo(getOperator().getOutputType(), valueType);
    }

    @Override
    public Component getName() {
        return getOperator().getLocalizedNameFull();
    }

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

    @Override
    public IConfigRenderPattern getRenderPattern() {
        if (getOperator().getRenderPattern() == null) {
            throw new IllegalStateException("Tried to render a (possibly virtual) operator with a null render pattern: "
                    + getOperator().getUniqueName());
        }
        return getOperator().getRenderPattern();
    }

    @Override
    public void onInputSlotUpdated(Player player, int slotId, ItemStack itemStack) {
        IVariableFacade variableFacade = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class).handle(ValueDeseralizationContext.of(player.level()), itemStack);
        inputVariables[slotId] = variableFacade;
    }

    @Override
    public boolean canWriteElementPre() {
        for (IVariableFacade inputVariable : inputVariables) {
            if (inputVariable == null || !inputVariable.isValid()) {
                return false;
            }
        }
        return true;
    }

    protected int[] getVariableIds(IVariableFacade[] inputVariables) {
        int[] variableIds = new int[inputVariables.length];
        for (int i = 0; i < inputVariables.length; i++) {
            variableIds[i] = inputVariables[i].getId();
        }
        return variableIds;
    }

    @Override
    public ItemStack writeElement(Player player, ItemStack itemStack) {
        IVariableFacadeHandlerRegistry registry = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class);
        int[] variableIds = getVariableIds(inputVariables);
        return registry.writeVariableFacadeItem(!player.level().isClientSide(), itemStack, Operators.REGISTRY,
                new OperatorVariableFacadeFactory(operator, variableIds), player.level(), player, RegistryEntries.BLOCK_LOGIC_PROGRAMMER.get().defaultBlockState());
    }

    @Override
    public void loadElement(IVariableFacade variableFacade) {
        if (variableFacade instanceof OperatorVariableFacade operatorVariableFacade) {
            int[] variableIds = operatorVariableFacade.getVariableIds();
            this.inputVariables = new IVariableFacade[variableIds.length];
            for (int i = 0; i < variableIds.length; i++) {
                IValueType valueType = operator.getInputTypes()[i];
                if (valueType instanceof IValueTypeCategory<?> valueTypeCategory) {
                    valueType = Iterables.getFirst(valueTypeCategory.getElements(), valueType);
                }
                this.inputVariables[i] = new ValueTypeVariableFacade(variableIds[i], valueType, valueType.getDefault());
            }
        }
    }

    @Override
    public void setValueInGui(RenderPattern subGui) {
        setValueInContainer((ContainerLogicProgrammerBase) subGui.container);
    }

    @Override
    public void setValueInContainer(ContainerLogicProgrammerBase container) {
        SimpleInventory inputSlots = container.getTemporaryInputSlots();
        for (int i = 0; i < inputSlots.getContainerSize(); i++) {
            ItemStack itemStack = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class).writeVariableFacadeItem(new ItemStack(RegistryEntries.ITEM_VARIABLE), inputVariables[i], (IVariableFacadeHandler) ValueTypes.REGISTRY);
            inputSlots.setItem(i, itemStack);
        }
    }

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

    @Override
    public void activate() {
        this.inputVariables = new IVariableFacade[getRenderPattern().getSlotPositions().length];
    }

    @Override
    public void deactivate() {
        this.inputVariables = null;
    }

    @Override
    public Component validate() {
        return getOperator().validateTypes(ValueHelpers.from(inputVariables));
    }

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

    @Override
    public String getSymbol() {
        return getOperator().getSymbol();
    }

    @Override
    public boolean isFor(IVariableFacade variableFacade) {
        if (variableFacade instanceof IOperatorVariableFacade) {
            IOperatorVariableFacade operatorFacade = (IOperatorVariableFacade) variableFacade;
            if (operatorFacade.isValid()) {
                return getOperator() == operatorFacade.getOperator();
            }
        }
        return false;
    }

    @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
    public boolean isFocused(RenderPattern subGui) {
        return focused;
    }

    @Override
    public void setFocused(RenderPattern subGui, boolean focused) {
        this.focused = focused;
    }

    @Override
    @OnlyIn(Dist.CLIENT)
    public RenderPattern createSubGui(int baseX, int baseY, int maxWidth, int maxHeight,
                                      ContainerScreenLogicProgrammerBase gui, ContainerLogicProgrammerBase container) {
        return new OperatorLPElementRenderPattern(this, baseX, baseY, maxWidth, maxHeight, gui, container);
    }

    public static class OperatorVariableFacadeFactory implements IVariableFacadeHandlerRegistry.IVariableFacadeFactory<IOperatorVariableFacade> {

        private final IOperator operator;
        private final int[] variableIds;

        public OperatorVariableFacadeFactory(IOperator operator, int[] variableIds) {
            this.operator = operator;
            this.variableIds = variableIds;
        }

        @Override
        public IOperatorVariableFacade create(boolean generateId) {
            return new OperatorVariableFacade(generateId, operator, variableIds);
        }

        @Override
        public IOperatorVariableFacade create(int id) {
            return new OperatorVariableFacade(id, operator, variableIds);
        }
    }

}

1	package org.cyclops.integrateddynamics.core.logicprogrammer;
2
3	import com.google.common.collect.Iterables;
4	import lombok.Data;
5	import net.minecraft.network.chat.Component;
6	import net.minecraft.world.entity.player.Player;
7	import net.minecraft.world.inventory.ClickType;
8	import net.minecraft.world.inventory.Slot;
9	import net.minecraft.world.item.ItemStack;
10	import net.neoforged.api.distmarker.Dist;
11	import net.neoforged.api.distmarker.OnlyIn;
12	import org.cyclops.cyclopscore.inventory.SimpleInventory;
13	import org.cyclops.integrateddynamics.IntegratedDynamics;
14	import org.cyclops.integrateddynamics.RegistryEntries;
15	import org.cyclops.integrateddynamics.api.evaluate.operator.IOperator;
16	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
17	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeCategory;
18	import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
19	import org.cyclops.integrateddynamics.api.item.IOperatorVariableFacade;
20	import org.cyclops.integrateddynamics.api.item.IVariableFacade;
21	import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandler;
22	import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandlerRegistry;
23	import org.cyclops.integrateddynamics.api.logicprogrammer.IConfigRenderPattern;
24	import org.cyclops.integrateddynamics.api.logicprogrammer.ILogicProgrammerElement;
25	import org.cyclops.integrateddynamics.api.logicprogrammer.ILogicProgrammerElementType;
26	import org.cyclops.integrateddynamics.client.gui.container.ContainerScreenLogicProgrammerBase;
27	import org.cyclops.integrateddynamics.core.evaluate.operator.Operators;
28	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueHelpers;
29	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
30	import org.cyclops.integrateddynamics.core.item.OperatorVariableFacade;
31	import org.cyclops.integrateddynamics.core.item.ValueTypeVariableFacade;
32	import org.cyclops.integrateddynamics.inventory.container.ContainerLogicProgrammerBase;
33
34	import java.util.List;
35
36	/**
37	* Element for operator.
38	*
39	* @author rubensworks
40	*/
41	@Data	×
42	public class OperatorLPElement implements ILogicProgrammerElement<RenderPattern, ContainerScreenLogicProgrammerBase, ContainerLogicProgrammerBase> {
43
44	private final IOperator operator;	×
45	private IVariableFacade[] inputVariables;	×
46	private boolean focused = false;	×
47
48	@Override
49	public ILogicProgrammerElementType getType() {
50	return LogicProgrammerElementTypes.OPERATOR;	×
51	}
52
53	@Override
54	public String getMatchString() {
55	return getOperator().getLocalizedNameFull().getString().toLowerCase();	×
56	}
57
58	@Override
59	public boolean matchesInput(IValueType valueType) {
60	for (IValueType operatorIn : getOperator().getInputTypes()) {	×
61	if(ValueHelpers.correspondsTo(operatorIn, valueType)) {	×
62	return true;	×
63	}
64	}
65	return false;	×
66	}
67
68	@Override
69	public boolean matchesOutput(IValueType valueType) {
70	return ValueHelpers.correspondsTo(getOperator().getOutputType(), valueType);	×
71	}
72
73	@Override
74	public Component getName() {
75	return getOperator().getLocalizedNameFull();	×
76	}
77
78	@Override
79	public void loadTooltip(List<Component> lines) {
80	getOperator().loadTooltip(lines, true);	×
81	}	×
82
83	@Override
84	public IConfigRenderPattern getRenderPattern() {
85	if (getOperator().getRenderPattern() == null) {	×
86	throw new IllegalStateException("Tried to render a (possibly virtual) operator with a null render pattern: "	×
87	+ getOperator().getUniqueName());	×
88	}
89	return getOperator().getRenderPattern();	×
90	}
91
92	@Override
93	public void onInputSlotUpdated(Player player, int slotId, ItemStack itemStack) {
94	IVariableFacade variableFacade = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class).handle(ValueDeseralizationContext.of(player.level()), itemStack);	×
95	inputVariables[slotId] = variableFacade;	×
96	}	×
97
98	@Override
99	public boolean canWriteElementPre() {
100	for (IVariableFacade inputVariable : inputVariables) {	×
101	if (inputVariable == null \|\| !inputVariable.isValid()) {	×
102	return false;	×
103	}
104	}
105	return true;	×
106	}
107
108	protected int[] getVariableIds(IVariableFacade[] inputVariables) {
109	int[] variableIds = new int[inputVariables.length];	×
110	for (int i = 0; i < inputVariables.length; i++) {	×
111	variableIds[i] = inputVariables[i].getId();	×
112	}
113	return variableIds;	×
114	}
115
116	@Override
117	public ItemStack writeElement(Player player, ItemStack itemStack) {
118	IVariableFacadeHandlerRegistry registry = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class);	×
119	int[] variableIds = getVariableIds(inputVariables);	×
120	return registry.writeVariableFacadeItem(!player.level().isClientSide(), itemStack, Operators.REGISTRY,	×
121	new OperatorVariableFacadeFactory(operator, variableIds), player.level(), player, RegistryEntries.BLOCK_LOGIC_PROGRAMMER.get().defaultBlockState());	×
122	}
123
124	@Override
125	public void loadElement(IVariableFacade variableFacade) {
126	if (variableFacade instanceof OperatorVariableFacade operatorVariableFacade) {	×
127	int[] variableIds = operatorVariableFacade.getVariableIds();	×
128	this.inputVariables = new IVariableFacade[variableIds.length];	×
129	for (int i = 0; i < variableIds.length; i++) {	×
130	IValueType valueType = operator.getInputTypes()[i];	×
131	if (valueType instanceof IValueTypeCategory<?> valueTypeCategory) {	×
132	valueType = Iterables.getFirst(valueTypeCategory.getElements(), valueType);	×
133	}
134	this.inputVariables[i] = new ValueTypeVariableFacade(variableIds[i], valueType, valueType.getDefault());	×
135	}
136	}
137	}	×
138
139	@Override
140	public void setValueInGui(RenderPattern subGui) {
141	setValueInContainer((ContainerLogicProgrammerBase) subGui.container);	×
142	}	×
143
144	@Override
145	public void setValueInContainer(ContainerLogicProgrammerBase container) {
146	SimpleInventory inputSlots = container.getTemporaryInputSlots();	×
147	for (int i = 0; i < inputSlots.getContainerSize(); i++) {	×
148	ItemStack itemStack = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class).writeVariableFacadeItem(new ItemStack(RegistryEntries.ITEM_VARIABLE), inputVariables[i], (IVariableFacadeHandler) ValueTypes.REGISTRY);	×
149	inputSlots.setItem(i, itemStack);	×
150	}
151	}	×
152
153	@Override
154	public boolean canCurrentlyReadFromOtherItem() {
155	return true;	×
156	}
157
158	@Override
159	public void activate() {
160	this.inputVariables = new IVariableFacade[getRenderPattern().getSlotPositions().length];	×
161	}	×
162
163	@Override
164	public void deactivate() {
165	this.inputVariables = null;	×
166	}	×
167
168	@Override
169	public Component validate() {
170	return getOperator().validateTypes(ValueHelpers.from(inputVariables));	×
171	}
172
173	@Override
174	public int getColor() {
175	return getOperator().getOutputType().getDisplayColor();	×
176	}
177
178	@Override
179	public String getSymbol() {
180	return getOperator().getSymbol();	×
181	}
182
183	@Override
184	public boolean isFor(IVariableFacade variableFacade) {
185	if (variableFacade instanceof IOperatorVariableFacade) {	×
186	IOperatorVariableFacade operatorFacade = (IOperatorVariableFacade) variableFacade;	×
187	if (operatorFacade.isValid()) {	×
188	return getOperator() == operatorFacade.getOperator();	×
189	}
190	}
191	return false;	×
192	}
193
194	@Override
195	public boolean isItemValidForSlot(int slotId, ItemStack itemStack) {
196	return itemStack.getItem() == RegistryEntries.ITEM_VARIABLE.get();	×
197	}
198
199	@Override
200	public boolean slotClick(int slotId, Slot slot, int mouseButton, ClickType clickType, Player player) {
201	return false;	×
202	}
203
204	@Override
205	public int getItemStackSizeLimit() {
206	return 1;	×
207	}
208
209	@Override
210	public boolean isFocused(RenderPattern subGui) {
211	return focused;	×
212	}
213
214	@Override
215	public void setFocused(RenderPattern subGui, boolean focused) {
216	this.focused = focused;	×
217	}	×
218
219	@Override
220	@OnlyIn(Dist.CLIENT)
221	public RenderPattern createSubGui(int baseX, int baseY, int maxWidth, int maxHeight,
222	ContainerScreenLogicProgrammerBase gui, ContainerLogicProgrammerBase container) {
223	return new OperatorLPElementRenderPattern(this, baseX, baseY, maxWidth, maxHeight, gui, container);	×
224	}
225
226	public static class OperatorVariableFacadeFactory implements IVariableFacadeHandlerRegistry.IVariableFacadeFactory<IOperatorVariableFacade> {
227
228	private final IOperator operator;
229	private final int[] variableIds;
230
231	public OperatorVariableFacadeFactory(IOperator operator, int[] variableIds) {	2✔
232	this.operator = operator;	3✔
233	this.variableIds = variableIds;	3✔
234	}	1✔
235
236	@Override
237	public IOperatorVariableFacade create(boolean generateId) {
238	return new OperatorVariableFacade(generateId, operator, variableIds);	9✔
239	}
240
241	@Override
242	public IOperatorVariableFacade create(int id) {
243	return new OperatorVariableFacade(id, operator, variableIds);	×
244	}
245	}
246
247	}

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