42512800491

Committed 08 Nov 2026 06:34PM UTC coverage: 58.683% (+0.3%) from 58.387%

Build # 42512800491

Build Type

Pull #1783

github

Committed by

claude

Commit Message

Merge remote-tracking branch 'origin/master-26-lts' into master-26

Ports the expressions of the Logic Programmer to Minecraft 26.3:
- Keys and mouse buttons use the SDL codes of InputConstants instead of GLFW.
  Undo and redo read the shortcut key, so they follow the keyboard layout, and
  Ctrl, or Cmd on macOS, comes from the key event, as Minecraft#hasControlDown
  no longer means Cmd on macOS.
- The expression text field starts SDL text input when it gets focus, without
  which no typed characters arrive.
- Blocks without properties are written as their id alone in 26.3, so a typed
  compound with only an id is kept when it is written as that id.
- MinMaxBounds, the screen, the left and top of containers, advancement icons and
  color names follow their 26.3 replacements.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MHtucHo4Qy2pTfBMgeE54y

Pull Request Pull Request #1783: Upmerge expressions in the Logic Programmer to 26.3

Coverage Stats

5838 of 13555 branches covered (43.07%)

Branch coverage included in aggregate %.

26172 of 40992 relevant lines covered (63.85%)

3.35 hits per line

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

67.65

/src/main/java/org/cyclops/integrateddynamics/core/evaluate/variable/ValueObjectTypeItemStack.java

package org.cyclops.integrateddynamics.core.evaluate.variable;

import net.minecraft.advancements.predicates.ItemPredicate;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.MutableComponent;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.storage.ValueInput;
import net.minecraft.world.level.storage.ValueOutput;
import org.cyclops.commoncapabilities.api.capability.itemhandler.ItemMatch;
import org.cyclops.cyclopscore.helper.IModHelpers;
import org.cyclops.integrateddynamics.api.advancement.criterion.ValuePredicate;
import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeNamed;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeNullable;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeUniquelyNamed;
import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeItemStackLPElement;
import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeLPElementBase;

import java.util.Objects;
import java.util.Optional;

/**
 * Value type with values that are itemstacks.
 * @author rubensworks
 */
public class ValueObjectTypeItemStack extends ValueObjectTypeBase<ValueObjectTypeItemStack.ValueItemStack> implements
        IValueTypeNamed<ValueObjectTypeItemStack.ValueItemStack>,
        IValueTypeUniquelyNamed<ValueObjectTypeItemStack.ValueItemStack>,
        IValueTypeNullable<ValueObjectTypeItemStack.ValueItemStack> {

    public ValueObjectTypeItemStack() {
        // TODO: in next major, prefix the global interact names of operators on items with item instead of itemstack.
        super("itemstack", ValueObjectTypeItemStack.ValueItemStack.class);
    }

    @Override
    public String getExpressionName() {
        return "Item";
    }

    public static MutableComponent getItemStackDisplayNameUsSafe(ItemStack itemStack) throws NoSuchMethodException {
        return !itemStack.isEmpty()
                ? (itemStack.getHoverName().copy().append((itemStack.getCount() > 1 ? " (" + itemStack.getCount() + ")" : "")))
                : Component.literal("");
    }

    public static MutableComponent getItemStackDisplayNameSafe(ItemStack itemStack) {
        // Certain mods may call client-side only methods,
        // so call a server-side-safe fallback method if that fails.
        try {
            return getItemStackDisplayNameUsSafe(itemStack);
        } catch (NoSuchMethodException e) {
            return Component.translatable(itemStack.getItem().getDescriptionId());
        }
    }

    @Override
    public ValueItemStack getDefault() {
        return ValueItemStack.of(ItemStack.EMPTY);
    }

    @Override
    public MutableComponent toCompactString(ValueItemStack value) {
        return ValueObjectTypeItemStack.getItemStackDisplayNameSafe(value.getRawValue());
    }

    @Override
    public void serialize(ValueOutput valueOutput, ValueItemStack value) {
        valueOutput = valueOutput.child("v");
        ItemStack itemStack;
        itemStack = value.getRawValue();
        int count = itemStack.getCount();
        if (itemStack.getCount() > 99) {
            itemStack = itemStack.copy();
            itemStack.setCount(99);
        }
        if (count > 99) {
            valueOutput.putInt("ExtendedCount", count);
        }
        valueOutput.store("stack", ItemStack.OPTIONAL_CODEC, itemStack);
    }

    @Override
    public ValueItemStack deserialize(ValueInput valueInput) {
        valueInput = valueInput.child("v").orElseThrow();
        ItemStack itemStack = valueInput.read("stack", ItemStack.OPTIONAL_CODEC).orElseThrow();
        valueInput.getInt("ExtendedCount").ifPresent(itemStack::setCount);
        return ValueItemStack.of(itemStack);
    }

    @Override
    public String getName(ValueItemStack a) {
        return toCompactString(a).getString();
    }

    @Override
    public boolean isNull(ValueItemStack a) {
        return a.getRawValue().isEmpty();
    }

    @Override
    public ValueTypeLPElementBase createLogicProgrammerElement() {
        return new ValueTypeItemStackLPElement<>(this, new ValueTypeItemStackLPElement.IItemStackToValue<ValueObjectTypeItemStack.ValueItemStack>() {
            @Override
            public boolean isNullable() {
                return true;
            }

            @Override
            public Component validate(ItemStack itemStack) {
                return null;
            }

            @Override
            public ValueObjectTypeItemStack.ValueItemStack getValue(ItemStack itemStack) {
                return ValueObjectTypeItemStack.ValueItemStack.of(itemStack);
            }

            @Override
            public ItemStack getValueAsItemStack(ValueItemStack value) {
                return value.getRawValue();
            }
        });
    }

    @Override
    public ValueItemStack materialize(ValueItemStack value) throws EvaluationException {
        return ValueItemStack.of(value.getRawValue().copy());
    }

    @Override
    public String getUniqueName(ValueItemStack value) {
        ItemStack itemStack = value.getRawValue();
        return !itemStack.isEmpty() ? BuiltInRegistries.ITEM.getKey(itemStack.getItem()).toString() : "";
    }

    public static class ValueItemStack extends ValueBase {

        private final ItemStack itemStack;

        private ValueItemStack(ItemStack itemStack) {
            super(ValueTypes.OBJECT_ITEMSTACK);
            this.itemStack = Objects.requireNonNull(itemStack, "Attempted to create a ValueItemStack for a null ItemStack.");
        }

        public static ValueItemStack of(ItemStack itemStack) {
            return new ValueItemStack(itemStack);
        }

        public ItemStack getRawValue() {
            return itemStack;
        }

        @Override
        public boolean equals(Object o) {
            return o instanceof ValueItemStack && ItemMatch.areItemStacksEqual(((ValueItemStack) o).itemStack, this.itemStack, ItemMatch.EXACT);
        }

        @Override
        public int hashCode() {
            return 37 + IModHelpers.get().getItemStackHelpers().getItemStackHashCode(itemStack);
        }

        @Override
        public String toString() {
            return "ValueItemStack(itemStack=" + this.itemStack + ")";
        }
    }

    public static class ValueItemStackPredicate extends ValuePredicate<ValueItemStack> {

        private final Optional<ItemPredicate> itemPredicate;

        public ValueItemStackPredicate(Optional<ItemPredicate> itemPredicate) {
            super(Optional.of(ValueTypes.OBJECT_ITEMSTACK), Optional.empty(), Optional.empty());
            this.itemPredicate = itemPredicate;
        }

        public Optional<ItemPredicate> getItemPredicate() {
            return itemPredicate;
        }

        @Override
        protected boolean testTyped(ValueItemStack value) {
            return super.testTyped(value) && (itemPredicate.isEmpty() || itemPredicate.get().test(value.getRawValue()));
        }
    }

}

1	package org.cyclops.integrateddynamics.core.evaluate.variable;
2
3	import net.minecraft.advancements.predicates.ItemPredicate;
4	import net.minecraft.core.registries.BuiltInRegistries;
5	import net.minecraft.network.chat.Component;
6	import net.minecraft.network.chat.MutableComponent;
7	import net.minecraft.world.item.ItemStack;
8	import net.minecraft.world.level.storage.ValueInput;
9	import net.minecraft.world.level.storage.ValueOutput;
10	import org.cyclops.commoncapabilities.api.capability.itemhandler.ItemMatch;
11	import org.cyclops.cyclopscore.helper.IModHelpers;
12	import org.cyclops.integrateddynamics.api.advancement.criterion.ValuePredicate;
13	import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
14	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeNamed;
15	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeNullable;
16	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeUniquelyNamed;
17	import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeItemStackLPElement;
18	import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeLPElementBase;
19
20	import java.util.Objects;
21	import java.util.Optional;
22
23	/**
24	* Value type with values that are itemstacks.
25	* @author rubensworks
26	*/
27	public class ValueObjectTypeItemStack extends ValueObjectTypeBase<ValueObjectTypeItemStack.ValueItemStack> implements
28	IValueTypeNamed<ValueObjectTypeItemStack.ValueItemStack>,
29	IValueTypeUniquelyNamed<ValueObjectTypeItemStack.ValueItemStack>,
30	IValueTypeNullable<ValueObjectTypeItemStack.ValueItemStack> {
31
32	public ValueObjectTypeItemStack() {
33	// TODO: in next major, prefix the global interact names of operators on items with item instead of itemstack.
34	super("itemstack", ValueObjectTypeItemStack.ValueItemStack.class);	4 ✔
35	}	1 ✔
36
37	@Override
38	public String getExpressionName() {
39	return "Item";	2 ✔
40	}
41
42	public static MutableComponent getItemStackDisplayNameUsSafe(ItemStack itemStack) throws NoSuchMethodException {
43	return !itemStack.isEmpty()	4 !
44	? (itemStack.getHoverName().copy().append((itemStack.getCount() > 1 ? " (" + itemStack.getCount() + ")" : "")))	×
45	: Component.literal("");	2 ✔
46	}
47
48	public static MutableComponent getItemStackDisplayNameSafe(ItemStack itemStack) {
49	// Certain mods may call client-side only methods,
50	// so call a server-side-safe fallback method if that fails.
51	try {
52	return getItemStackDisplayNameUsSafe(itemStack);	3 ✔
53	} catch (NoSuchMethodException e) {	×
54	return Component.translatable(itemStack.getItem().getDescriptionId());	×
55	}
56	}
57
58	@Override
59	public ValueItemStack getDefault() {
60	return ValueItemStack.of(ItemStack.EMPTY);	×
61	}
62
63	@Override
64	public MutableComponent toCompactString(ValueItemStack value) {
65	return ValueObjectTypeItemStack.getItemStackDisplayNameSafe(value.getRawValue());	4 ✔
66	}
67
68	@Override
69	public void serialize(ValueOutput valueOutput, ValueItemStack value) {
70	valueOutput = valueOutput.child("v");	4 ✔
71	ItemStack itemStack;
72	itemStack = value.getRawValue();	3 ✔
73	int count = itemStack.getCount();	3 ✔
74	if (itemStack.getCount() > 99) {	4 ✔
75	itemStack = itemStack.copy();	3 ✔
76	itemStack.setCount(99);	3 ✔
77	}
78	if (count > 99) {	3 ✔
79	valueOutput.putInt("ExtendedCount", count);	4 ✔
80	}
81	valueOutput.store("stack", ItemStack.OPTIONAL_CODEC, itemStack);	5 ✔
82	}	1 ✔
83
84	@Override
85	public ValueItemStack deserialize(ValueInput valueInput) {
86	valueInput = valueInput.child("v").orElseThrow();	6 ✔
87	ItemStack itemStack = valueInput.read("stack", ItemStack.OPTIONAL_CODEC).orElseThrow();	7 ✔
88	valueInput.getInt("ExtendedCount").ifPresent(itemStack::setCount);	9 ✔
89	return ValueItemStack.of(itemStack);	3 ✔
90	}
91
92	@Override
93	public String getName(ValueItemStack a) {
94	return toCompactString(a).getString();	×
95	}
96
97	@Override
98	public boolean isNull(ValueItemStack a) {
99	return a.getRawValue().isEmpty();	×
100	}
101
102	@Override
103	public ValueTypeLPElementBase createLogicProgrammerElement() {
104	return new ValueTypeItemStackLPElement<>(this, new ValueTypeItemStackLPElement.IItemStackToValue<ValueObjectTypeItemStack.ValueItemStack>() {	17 ✔
105	@Override
106	public boolean isNullable() {
107	return true;	×
108	}
109
110	@Override
111	public Component validate(ItemStack itemStack) {
112	return null;	×
113	}
114
115	@Override
116	public ValueObjectTypeItemStack.ValueItemStack getValue(ItemStack itemStack) {
117	return ValueObjectTypeItemStack.ValueItemStack.of(itemStack);	×
118	}
119
120	@Override
121	public ItemStack getValueAsItemStack(ValueItemStack value) {
122	return value.getRawValue();	×
123	}
124	});
125	}
126
127	@Override
128	public ValueItemStack materialize(ValueItemStack value) throws EvaluationException {
129	return ValueItemStack.of(value.getRawValue().copy());	5 ✔
130	}
131
132	@Override
133	public String getUniqueName(ValueItemStack value) {
134	ItemStack itemStack = value.getRawValue();	×
135	return !itemStack.isEmpty() ? BuiltInRegistries.ITEM.getKey(itemStack.getItem()).toString() : "";	×
136	}
137
138	public static class ValueItemStack extends ValueBase {
139
140	private final ItemStack itemStack;
141
142	private ValueItemStack(ItemStack itemStack) {
143	super(ValueTypes.OBJECT_ITEMSTACK);	3 ✔
144	this.itemStack = Objects.requireNonNull(itemStack, "Attempted to create a ValueItemStack for a null ItemStack.");	6 ✔
145	}	1 ✔
146
147	public static ValueItemStack of(ItemStack itemStack) {
148	return new ValueItemStack(itemStack);	5 ✔
149	}
150
151	public ItemStack getRawValue() {
152	return itemStack;	3 ✔
153	}
154
155	@Override
156	public boolean equals(Object o) {
157	return o instanceof ValueItemStack && ItemMatch.areItemStacksEqual(((ValueItemStack) o).itemStack, this.itemStack, ItemMatch.EXACT);	15 !
158	}
159
160	@Override
161	public int hashCode() {
162	return 37 + IModHelpers.get().getItemStackHelpers().getItemStackHashCode(itemStack);	×
163	}
164
165	@Override
166	public String toString() {
167	return "ValueItemStack(itemStack=" + this.itemStack + ")";	5 ✔
168	}
169	}
170
171	public static class ValueItemStackPredicate extends ValuePredicate<ValueItemStack> {
172
173	private final Optional<ItemPredicate> itemPredicate;
174
175	public ValueItemStackPredicate(Optional<ItemPredicate> itemPredicate) {
176	super(Optional.of(ValueTypes.OBJECT_ITEMSTACK), Optional.empty(), Optional.empty());	6 ✔
177	this.itemPredicate = itemPredicate;	3 ✔
178	}	1 ✔
179
180	public Optional<ItemPredicate> getItemPredicate() {
181	return itemPredicate;	×
182	}
183
184	@Override
185	protected boolean testTyped(ValueItemStack value) {
186	return super.testTyped(value) && (itemPredicate.isEmpty() \|\| itemPredicate.get().test(value.getRawValue()));	20 !
187	}
188	}
189
190	}

CyclopsMC / IntegratedDynamics / 42512800491

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