22186773560

Committed 19 Feb 2026 02:52PM UTC coverage: 52.603% (+0.2%) from 52.363%

Build # 22186773560

Build Type

push

github

Committed by

web-flow

Commit Message

Remove Lombok dependency (#1604)

Run Details

2911 of 8664 branches covered (33.6%)

Branch coverage included in aggregate %.

17683 of 30486 relevant lines covered (58.0%)

3.01 hits per line

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

15.84

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

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

import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.MutableComponent;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.EntityType;
import net.minecraft.world.entity.item.ItemEntity;
import net.minecraft.world.level.storage.ValueInput;
import net.minecraft.world.level.storage.ValueOutput;
import net.neoforged.neoforge.server.ServerLifecycleHooks;
import org.cyclops.cyclopscore.helper.IModHelpers;
import org.cyclops.integrateddynamics.api.advancement.criterion.ValuePredicate;
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.ValueTypeLPElementBase;

import javax.annotation.Nullable;
import java.util.Optional;
import java.util.UUID;

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

    public ValueObjectTypeEntity() {
        super("entity", ValueObjectTypeEntity.ValueEntity.class);
    }

    @Override
    public ValueEntity getDefault() {
        return ValueEntity.of((UUID) null);
    }

    @Override
    public MutableComponent toCompactString(ValueEntity value) {
        Optional<UUID> uuid = value.getUuid();
        if (uuid.isPresent()) {
            Optional<Entity> entity = value.getRawValue();
            if(entity.isPresent()) {
                Entity e = entity.get();
                if(e instanceof ItemEntity) {
                    return (MutableComponent) ((ItemEntity) e).getItem().getHoverName();
                } else {
                    return (MutableComponent) e.getName();
                }
            }
            return Component.literal("unknown");
        }
        return Component.literal("");
    }

    @Override
    public void serialize(ValueOutput valueOutput, ValueEntity value) {
        value.getUuid().ifPresent(v -> valueOutput.putString("v", v.toString()));
    }

    @Override
    public ValueEntity deserialize(ValueInput valueInput) {
        return ValueEntity.of(valueInput.getString("v").map(UUID::fromString).orElse(null));
    }

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

    @Override
    public boolean isNull(ValueEntity a) {
        return !a.getRawValue().isPresent();
    }

    @Override
    public ValueTypeLPElementBase createLogicProgrammerElement() {
        return null;
    }

    @Override
    public String getUniqueName(ValueEntity value) {
        Optional<UUID> uuid = value.getUuid();
        if (uuid.isPresent()) {
            UUID id = uuid.get();
            String entityName = value.getRawValue()
                    .map(entity -> BuiltInRegistries.ENTITY_TYPE.getKey(entity.getType()).toString())
                    .orElse("unknown");
            return id.toString() + " (" + entityName + ")";
        }
        return "";
    }

    public static class ValueEntity extends ValueBase {

        private final Optional<UUID> value;

        protected ValueEntity(@Nullable Entity value) {
            super(ValueTypes.OBJECT_ENTITY);
            this.value = value == null ? Optional.<UUID>empty() : Optional.of(value.getUUID());
        }

        private ValueEntity(@Nullable UUID entityUuid) {
            super(ValueTypes.OBJECT_ENTITY);
            this.value = Optional.ofNullable(entityUuid);
        }

        /**
         * @return The raw value in an optional holder.
         */
        public Optional<Entity> getRawValue() {
            Optional<UUID> uuid = getUuid();
            if (uuid.isPresent()) {
                if (IModHelpers.get().getMinecraftHelpers().isClientSideThread()) {
                    return ValueObjectTypeEntityClient.getEntity(uuid.get());
                }
                for (ServerLevel world : ServerLifecycleHooks.getCurrentServer().getAllLevels()) {
                    Entity entity = world.getEntity(uuid.get());
                    if (entity != null) {
                        return Optional.of(entity);
                    }
                }
            }
            return Optional.empty();
        }

        public Optional<UUID> getUuid() {
            return value;
        }

        @Override
        public boolean equals(Object o) {
            if(o instanceof ValueEntity) {
                if (((ValueEntity) o).value.isPresent() && value.isPresent()) {
                    return ((ValueEntity) o).value.get().equals(value.get());
                } else if (!((ValueEntity) o).value.isPresent() && !value.isPresent()) {
                    return true;
                }
            }
            return false;
        }

        @Override
        public int hashCode() {
            return getType().hashCode() + (getRawValue().isPresent() ? getRawValue().get().hashCode() : 0);
        }

        public static ValueEntity of(@Nullable Entity entity) {
            return new ValueEntity(entity);
        }

        public static ValueEntity of(@Nullable UUID entityUuid) {
            return new ValueEntity(entityUuid);
        }

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

    }

    public static class ValueEntityPredicate extends ValuePredicate<ValueEntity> {

        private final Optional<EntityType<? extends Entity>> entityType;

        public ValueEntityPredicate(Optional<EntityType<? extends Entity>> entityType) {
            super(Optional.of(ValueTypes.OBJECT_ENTITY), Optional.empty(), Optional.empty());
            this.entityType = entityType;
        }

        public Optional<EntityType<? extends Entity>> getEntityType() {
            return entityType;
        }

        @Override
        protected boolean testTyped(ValueEntity value) {
            return super.testTyped(value)
                    && (entityType.isEmpty()
                        || (value.getRawValue().isPresent() && value.getRawValue().get().getType() == entityType.get()));
        }
    }

}

1	package org.cyclops.integrateddynamics.core.evaluate.variable;
2
3	import net.minecraft.core.registries.BuiltInRegistries;
4	import net.minecraft.network.chat.Component;
5	import net.minecraft.network.chat.MutableComponent;
6	import net.minecraft.server.level.ServerLevel;
7	import net.minecraft.world.entity.Entity;
8	import net.minecraft.world.entity.EntityType;
9	import net.minecraft.world.entity.item.ItemEntity;
10	import net.minecraft.world.level.storage.ValueInput;
11	import net.minecraft.world.level.storage.ValueOutput;
12	import net.neoforged.neoforge.server.ServerLifecycleHooks;
13	import org.cyclops.cyclopscore.helper.IModHelpers;
14	import org.cyclops.integrateddynamics.api.advancement.criterion.ValuePredicate;
15	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeNamed;
16	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeNullable;
17	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeUniquelyNamed;
18	import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeLPElementBase;
19
20	import javax.annotation.Nullable;
21	import java.util.Optional;
22	import java.util.UUID;
23
24	/**
25	* Value type with values that are itemstacks.
26	* @author rubensworks
27	*/
28	public class ValueObjectTypeEntity extends ValueObjectTypeBase<ValueObjectTypeEntity.ValueEntity> implements
29	IValueTypeNamed<ValueObjectTypeEntity.ValueEntity>, IValueTypeUniquelyNamed<ValueObjectTypeEntity.ValueEntity>,
30	IValueTypeNullable<ValueObjectTypeEntity.ValueEntity> {
31
32	public ValueObjectTypeEntity() {
33	super("entity", ValueObjectTypeEntity.ValueEntity.class);	4✔
34	}	1✔
35
36	@Override
37	public ValueEntity getDefault() {
38	return ValueEntity.of((UUID) null);	×
39	}
40
41	@Override
42	public MutableComponent toCompactString(ValueEntity value) {
43	Optional<UUID> uuid = value.getUuid();	×
44	if (uuid.isPresent()) {	×
45	Optional<Entity> entity = value.getRawValue();	×
46	if(entity.isPresent()) {	×
47	Entity e = entity.get();	×
48	if(e instanceof ItemEntity) {	×
49	return (MutableComponent) ((ItemEntity) e).getItem().getHoverName();	×
50	} else {
51	return (MutableComponent) e.getName();	×
52	}
53	}
54	return Component.literal("unknown");	×
55	}
56	return Component.literal("");	×
57	}
58
59	@Override
60	public void serialize(ValueOutput valueOutput, ValueEntity value) {
61	value.getUuid().ifPresent(v -> valueOutput.putString("v", v.toString()));	×
62	}	×
63
64	@Override
65	public ValueEntity deserialize(ValueInput valueInput) {
66	return ValueEntity.of(valueInput.getString("v").map(UUID::fromString).orElse(null));	×
67	}
68
69	@Override
70	public String getName(ValueEntity a) {
71	return toCompactString(a).getString();	×
72	}
73
74	@Override
75	public boolean isNull(ValueEntity a) {
76	return !a.getRawValue().isPresent();	×
77	}
78
79	@Override
80	public ValueTypeLPElementBase createLogicProgrammerElement() {
81	return null;	×
82	}
83
84	@Override
85	public String getUniqueName(ValueEntity value) {
86	Optional<UUID> uuid = value.getUuid();	×
87	if (uuid.isPresent()) {	×
88	UUID id = uuid.get();	×
89	String entityName = value.getRawValue()	×
90	.map(entity -> BuiltInRegistries.ENTITY_TYPE.getKey(entity.getType()).toString())	×
91	.orElse("unknown");	×
92	return id.toString() + " (" + entityName + ")";	×
93	}
94	return "";	×
95	}
96
97	public static class ValueEntity extends ValueBase {
98
99	private final Optional<UUID> value;
100
101	protected ValueEntity(@Nullable Entity value) {
102	super(ValueTypes.OBJECT_ENTITY);	3✔
103	this.value = value == null ? Optional.<UUID>empty() : Optional.of(value.getUUID());	7!
104	}	1✔
105
106	private ValueEntity(@Nullable UUID entityUuid) {
107	super(ValueTypes.OBJECT_ENTITY);	×
108	this.value = Optional.ofNullable(entityUuid);	×
109	}	×
110
111	/**
112	* @return The raw value in an optional holder.
113	*/
114	public Optional<Entity> getRawValue() {
115	Optional<UUID> uuid = getUuid();	×
116	if (uuid.isPresent()) {	×
117	if (IModHelpers.get().getMinecraftHelpers().isClientSideThread()) {	×
118	return ValueObjectTypeEntityClient.getEntity(uuid.get());	×
119	}
120	for (ServerLevel world : ServerLifecycleHooks.getCurrentServer().getAllLevels()) {	×
121	Entity entity = world.getEntity(uuid.get());	×
122	if (entity != null) {	×
123	return Optional.of(entity);	×
124	}
125	}	×
126	}
127	return Optional.empty();	×
128	}
129
130	public Optional<UUID> getUuid() {
131	return value;	×
132	}
133
134	@Override
135	public boolean equals(Object o) {
136	if(o instanceof ValueEntity) {	3!
137	if (((ValueEntity) o).value.isPresent() && value.isPresent()) {	9!
138	return ((ValueEntity) o).value.get().equals(value.get());	10✔
139	} else if (!((ValueEntity) o).value.isPresent() && !value.isPresent()) {	×
140	return true;	×
141	}
142	}
143	return false;	×
144	}
145
146	@Override
147	public int hashCode() {
148	return getType().hashCode() + (getRawValue().isPresent() ? getRawValue().get().hashCode() : 0);	×
149	}
150
151	public static ValueEntity of(@Nullable Entity entity) {
152	return new ValueEntity(entity);	5✔
153	}
154
155	public static ValueEntity of(@Nullable UUID entityUuid) {
156	return new ValueEntity(entityUuid);	×
157	}
158
159	@Override
160	public String toString() {
161	return "ValueEntity(value=" + this.value + ")";	×
162	}
163
164	}
165
166	public static class ValueEntityPredicate extends ValuePredicate<ValueEntity> {
167
168	private final Optional<EntityType<? extends Entity>> entityType;
169
170	public ValueEntityPredicate(Optional<EntityType<? extends Entity>> entityType) {
171	super(Optional.of(ValueTypes.OBJECT_ENTITY), Optional.empty(), Optional.empty());	6✔
172	this.entityType = entityType;	3✔
173	}	1✔
174
175	public Optional<EntityType<? extends Entity>> getEntityType() {
176	return entityType;	×
177	}
178
179	@Override
180	protected boolean testTyped(ValueEntity value) {
181	return super.testTyped(value)	×
182	&& (entityType.isEmpty()	×
183	\|\| (value.getRawValue().isPresent() && value.getRawValue().get().getType() == entityType.get()));	×
184	}
185	}
186
187	}

CyclopsMC / IntegratedDynamics / 22186773560

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