24313951665

Committed 12 Apr 2026 06:55PM UTC coverage: 53.986% (+0.07%) from 53.92%

Build # 24313951665

Build Type

Pull #1658

github

Committed by

web-flow

Commit Message

Update replaceable fluid tests to place block as player via ItemStack, triggering actual replaceable check

Agent-Logs-Url: https://github.com/CyclopsMC/IntegratedDynamics/sessions/466f2fc5-34d9-429c-a672-a72b3931d363

Co-authored-by: rubensworks <440384+rubensworks@users.noreply.github.com>

Pull Request Pull Request #1658: Fix Menril Resin and Liquid Chorus fluids being non-interactable in world

Coverage Stats

3096 of 8971 branches covered (34.51%)

Branch coverage included in aggregate %.

18906 of 31784 relevant lines covered (59.48%)

3.08 hits per line

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

86.73

/src/main/java/org/cyclops/integrateddynamics/IntegratedDynamics.java

package org.cyclops.integrateddynamics;

import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import net.minecraft.commands.CommandBuildContext;
import net.minecraft.commands.CommandSourceStack;
import net.minecraft.commands.Commands;
import net.minecraft.core.Registry;
import net.minecraft.gametest.framework.TestEnvironmentDefinition;
import net.minecraft.world.item.CreativeModeTab;
import net.minecraft.world.item.ItemStack;
import net.neoforged.bus.api.EventPriority;
import net.neoforged.bus.api.IEventBus;
import net.neoforged.fml.ModList;
import net.neoforged.fml.common.Mod;
import net.neoforged.fml.event.lifecycle.FMLCommonSetupEvent;
import net.neoforged.fml.javafmlmod.FMLModContainer;
import net.neoforged.neoforge.common.NeoForge;
import net.neoforged.neoforge.event.RegisterGameTestsEvent;
import net.neoforged.neoforge.event.server.ServerStartedEvent;
import net.neoforged.neoforge.registries.NewRegistryEvent;
import org.apache.logging.log4j.Level;
import org.cyclops.cyclopscore.config.ConfigHandlerCommon;
import org.cyclops.cyclopscore.gametest.GameTestLoaderHelpers;
import org.cyclops.cyclopscore.helper.IModHelpers;
import org.cyclops.cyclopscore.infobook.IInfoBookRegistry;
import org.cyclops.cyclopscore.infobook.InfoBookRegistry;
import org.cyclops.cyclopscore.init.ModBaseNeoForge;
import org.cyclops.cyclopscore.persist.world.GlobalCounters;
import org.cyclops.cyclopscore.proxy.IClientProxy;
import org.cyclops.cyclopscore.proxy.ICommonProxy;
import org.cyclops.integrateddynamics.api.client.model.IVariableModelProviderRegistry;
import org.cyclops.integrateddynamics.api.client.render.part.IPartOverlayRendererRegistry;
import org.cyclops.integrateddynamics.api.client.render.valuetype.IValueTypeWorldRendererRegistry;
import org.cyclops.integrateddynamics.api.evaluate.operator.IOperatorRegistry;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueCastRegistry;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeLightLevelRegistry;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeListProxyFactoryTypeRegistry;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeRegistry;
import org.cyclops.integrateddynamics.api.ingredient.IIngredientComponentHandlerRegistry;
import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandlerRegistry;
import org.cyclops.integrateddynamics.api.logicprogrammer.ILogicProgrammerElementTypeRegistry;
import org.cyclops.integrateddynamics.api.network.INetworkCraftingHandlerRegistry;
import org.cyclops.integrateddynamics.api.part.IPartTypeRegistry;
import org.cyclops.integrateddynamics.api.part.aspect.IAspectRegistry;
import org.cyclops.integrateddynamics.capability.ingredient.IngredientComponentCapabilities;
import org.cyclops.integrateddynamics.capability.network.NetworkCapabilityConstructors;
import org.cyclops.integrateddynamics.client.render.part.PartOverlayRendererRegistry;
import org.cyclops.integrateddynamics.client.render.part.PartOverlayRenderers;
import org.cyclops.integrateddynamics.client.render.valuetype.ValueTypeWorldRendererRegistry;
import org.cyclops.integrateddynamics.client.render.valuetype.ValueTypeWorldRenderers;
import org.cyclops.integrateddynamics.command.CommandCrash;
import org.cyclops.integrateddynamics.command.CommandGenerateNetwork;
import org.cyclops.integrateddynamics.command.CommandNetworkDiagnostics;
import org.cyclops.integrateddynamics.command.CommandTest;
import org.cyclops.integrateddynamics.core.NoteBlockEventReceiver;
import org.cyclops.integrateddynamics.core.TickHandler;
import org.cyclops.integrateddynamics.core.client.model.VariableModelProviderRegistry;
import org.cyclops.integrateddynamics.core.client.model.VariableModelProviders;
import org.cyclops.integrateddynamics.core.evaluate.DelayVariableFacadeHandler;
import org.cyclops.integrateddynamics.core.evaluate.ProxyVariableFacadeHandler;
import org.cyclops.integrateddynamics.core.evaluate.operator.OperatorRegistry;
import org.cyclops.integrateddynamics.core.evaluate.operator.Operators;
import org.cyclops.integrateddynamics.core.evaluate.variable.*;
import org.cyclops.integrateddynamics.core.event.IntegratedDynamicsSetupEvent;
import org.cyclops.integrateddynamics.core.ingredient.IngredientComponentHandlerRegistry;
import org.cyclops.integrateddynamics.core.ingredient.IngredientComponentHandlers;
import org.cyclops.integrateddynamics.core.item.VariableFacadeHandlerRegistry;
import org.cyclops.integrateddynamics.core.logicprogrammer.LogicProgrammerElementTypeRegistry;
import org.cyclops.integrateddynamics.core.logicprogrammer.LogicProgrammerElementTypes;
import org.cyclops.integrateddynamics.core.network.NetworkCraftingHandlerRegistry;
import org.cyclops.integrateddynamics.core.part.PartTypeRegistry;
import org.cyclops.integrateddynamics.core.part.PartTypes;
import org.cyclops.integrateddynamics.core.part.aspect.AspectRegistry;
import org.cyclops.integrateddynamics.core.persist.world.LabelsWorldStorage;
import org.cyclops.integrateddynamics.core.persist.world.NetworkWorldStorage;
import org.cyclops.integrateddynamics.gametest.*;
import org.cyclops.integrateddynamics.gametest.integration.GameTester;
import org.cyclops.integrateddynamics.infobook.OnTheDynamicsOfIntegrationBook;
import org.cyclops.integrateddynamics.item.ItemOnTheDynamicsOfIntegrationConfig;
import org.cyclops.integrateddynamics.metadata.RegistryExportables;
import org.cyclops.integrateddynamics.part.PartTypeConnectorOmniDirectional;
import org.cyclops.integrateddynamics.part.aspect.Aspects;
import org.cyclops.integrateddynamics.proxy.ClientProxy;
import org.cyclops.integrateddynamics.proxy.CommonProxy;

import java.lang.reflect.Field;

/**
 * The main mod class of IntegratedDynamics.
 * @author rubensworks
 *
 */
@Mod(Reference.MOD_ID)
public class IntegratedDynamics extends ModBaseNeoForge<IntegratedDynamics> {

    /**
     * The unique instance of this mod.
     */
    public static IntegratedDynamics _instance;

    public static GlobalCounters.Access globalCounters = null;

    public IntegratedDynamics(IEventBus modEventBus) {
        super(Reference.MOD_ID, (instance) -> _instance = instance, modEventBus);

        // Register world storages
        registerWorldStorage(NetworkWorldStorage.Access.getInstance(this));
        registerWorldStorage(globalCounters = new GlobalCounters.Access(this));
        registerWorldStorage(LabelsWorldStorage.Access.getInstance(this));

        getRegistryManager().addRegistry(IVariableFacadeHandlerRegistry.class, VariableFacadeHandlerRegistry.getInstance());
        getRegistryManager().addRegistry(IValueTypeRegistry.class, ValueTypeRegistry.getInstance());
        getRegistryManager().addRegistry(IValueCastRegistry.class, ValueCastRegistry.getInstance());
        getRegistryManager().addRegistry(IValueTypeListProxyFactoryTypeRegistry.class, ValueTypeListProxyFactoryTypeRegistry.getInstance());
        getRegistryManager().addRegistry(IValueTypeLightLevelRegistry.class, ValueTypeLightLevelRegistry.getInstance());
        getRegistryManager().addRegistry(IPartTypeRegistry.class, PartTypeRegistry.getInstance());
        getRegistryManager().addRegistry(IAspectRegistry.class, AspectRegistry.getInstance());
        getRegistryManager().addRegistry(IOperatorRegistry.class, OperatorRegistry.getInstance());
        getRegistryManager().addRegistry(ILogicProgrammerElementTypeRegistry.class, LogicProgrammerElementTypeRegistry.getInstance());
        if(getModHelpers().getMinecraftHelpers().isClientSide()) {
            getRegistryManager().addRegistry(IPartOverlayRendererRegistry.class, PartOverlayRendererRegistry.getInstance());
            getRegistryManager().addRegistry(IValueTypeWorldRendererRegistry.class, ValueTypeWorldRendererRegistry.getInstance());
            getRegistryManager().addRegistry(IVariableModelProviderRegistry.class, VariableModelProviderRegistry.getInstance());
        }

        getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class).registerHandler(ProxyVariableFacadeHandler.getInstance());
        getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class).registerHandler(DelayVariableFacadeHandler.getInstance());
        getRegistryManager().addRegistry(IInfoBookRegistry.class, new InfoBookRegistry());
        getRegistryManager().addRegistry(IIngredientComponentHandlerRegistry.class, IngredientComponentHandlerRegistry.getInstance());
        getRegistryManager().addRegistry(INetworkCraftingHandlerRegistry.class, NetworkCraftingHandlerRegistry.getInstance());

        // Preload parts, so we force their blocks and items to be registered
        PartTypes.load();

        modEventBus.addListener(EventPriority.LOWEST, IngredientComponentHandlers::onIngredientComponentsPopulated);
        modEventBus.addListener(this::onRegistriesCreate);
        modEventBus.register(new NetworkCapabilityConstructors());
        modEventBus.addListener(this::registerIntegrationGameTests);

        NeoForge.EVENT_BUS.addListener(this::onServerStartedLoadedGroups);
        NeoForge.EVENT_BUS.register(TickHandler.getInstance());
        NeoForge.EVENT_BUS.register(NoteBlockEventReceiver.getInstance());
    }

    public void onRegistriesCreate(NewRegistryEvent event) {
        IngredientComponentCapabilities.load();
    }

    @Override
    protected LiteralArgumentBuilder<CommandSourceStack> constructBaseCommand(Commands.CommandSelection selection, CommandBuildContext context) {
        LiteralArgumentBuilder<CommandSourceStack> root = super.constructBaseCommand(selection, context);

        root.then(CommandCrash.make());
        root.then(CommandGenerateNetwork.make());
        root.then(CommandNetworkDiagnostics.make());
        root.then(CommandTest.make());

        return root;
    }

    @Override
    protected void setup(FMLCommonSetupEvent event) {
        ValueTypes.load();
        IngredientComponentHandlers.load();
        ValueCastMappings.load();
        ValueTypeLightLevels.load();
        ValueTypeListProxyFactories.load();
        Operators.load();
        Aspects.load();
        PartTypes.register();
        LogicProgrammerElementTypes.load();
        RegistryExportables.load();

        // Register info book
        putGenericReference(ModBaseNeoForge.REFKEY_INFOBOOK_REWARDS, ItemOnTheDynamicsOfIntegrationConfig.bookRewards);
        getRegistryManager().getRegistry(IInfoBookRegistry.class).registerInfoBook(
                OnTheDynamicsOfIntegrationBook.getInstance(), "/data/" + Reference.MOD_ID + "/info/on_the_dynamics_of_integration.xml");

        IntegratedDynamicsSetupEvent integratedDynamicsSetupEvent = new IntegratedDynamicsSetupEvent(this.getContainer());
        ModList.get().forEachModContainer((name, container) -> {
            if (container instanceof FMLModContainer fmlModContainer) {
                fmlModContainer.getEventBus().post(integratedDynamicsSetupEvent);
            }
        });

        if(IModHelpers.get().getMinecraftHelpers().isClientSide()) {
            PartOverlayRenderers.load();
            ValueTypeWorldRenderers.load();
            VariableModelProviders.load();
        }

        super.setup(event);
    }

    protected void onServerStartedLoadedGroups(ServerStartedEvent event) {
        PartTypeConnectorOmniDirectional.LOADED_GROUPS.onStartedEvent(event);
    }

    @Override
    protected IClientProxy constructClientProxy() {
        return new ClientProxy();
    }

    @Override
    protected ICommonProxy constructCommonProxy() {
        return new CommonProxy();
    }

    @Override
    protected CreativeModeTab.Builder constructDefaultCreativeModeTab(CreativeModeTab.Builder builder) {
        return super.constructDefaultCreativeModeTab(builder)
                .icon(() -> new ItemStack(RegistryEntries.ITEM_CABLE));
    }

    @Override
    protected void onConfigsRegister(ConfigHandlerCommon configHandler) {
        super.onConfigsRegister(configHandler);

        configHandler.addConfigurable(new GeneralConfig());
        Configs.registerBlocks(configHandler);
    }

    @Override
    public Class<?>[] getGameTestClasses() {
        return new Class[]{
                GameTestsAdvancements.class,
                GameTestsAspectsReadAudio.class,
                GameTestsAspectsReadBlock.class,
                GameTestsAspectsReadEntity.class,
                GameTestsAspectsReadExtraDimensional.class,
                GameTestsAspectsReadFluid.class,
                GameTestsAspectsReadInventory.class,
                GameTestsAspectsReadMachine.class,
                GameTestsAspectsReadNetwork.class,
                GameTestsAspectsReadRedstone.class,
                GameTestsAspectsReadWorld.class,
                GameTestsAspectsWriteRedstone.class,
                GameTestsBattery.class,
                GameTestsCombinedAspects.class,
                GameTestsDelayer.class,
                GameTestsDryingBasin.class,
                GameTestsFacades.class,
                GameTestsFluids.class,
                GameTestsFuzzing.class,
                GameTestsGenerator.class,
                GameTestsMaterializer.class,
                GameTestsMechanicalDryingBasin.class,
                GameTestsMechanicalSqueezer.class,
                GameTestsNetwork.class,
                GameTestsOffsets.class,
                GameTestsParts.class,
                GameTestsPerformance.class,
                GameTestsProxy.class,
                GameTestsSqueezer.class,
                GameTestsWrench.class,
        };
    }

    protected void registerIntegrationGameTests(RegisterGameTestsEvent event) {
        if (!GameTestLoaderHelpers.areGameTestsEnabled(getModId())) {
            return;
        }
        try {
            Field field = RegisterGameTestsEvent.class.getDeclaredField("environmentsRegistry");
            field.setAccessible(true);
            Registry<TestEnvironmentDefinition<?>> testEnvironmentRegistry = (Registry<TestEnvironmentDefinition<?>>) field.get(event);
            GameTester.registerCommonTests(getModId(), event::registerTest, testEnvironmentRegistry);
            GameTestsFuzzing.registerCommonTests(getModId(), event::registerTest, testEnvironmentRegistry);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Log a new info message for this mod.
     * @param message The message to show.
     */
    public static void clog(String message) {
        IntegratedDynamics._instance.log(Level.INFO, message);
    }

    /**
     * Log a new message of the given level for this mod.
     * @param level The level in which the message must be shown.
     * @param message The message to show.
     */
    public static void clog(Level level, String message) {
        IntegratedDynamics._instance.log(level, message);
    }
}

1	package org.cyclops.integrateddynamics;
2
3	import com.mojang.brigadier.builder.LiteralArgumentBuilder;
4	import net.minecraft.commands.CommandBuildContext;
5	import net.minecraft.commands.CommandSourceStack;
6	import net.minecraft.commands.Commands;
7	import net.minecraft.core.Registry;
8	import net.minecraft.gametest.framework.TestEnvironmentDefinition;
9	import net.minecraft.world.item.CreativeModeTab;
10	import net.minecraft.world.item.ItemStack;
11	import net.neoforged.bus.api.EventPriority;
12	import net.neoforged.bus.api.IEventBus;
13	import net.neoforged.fml.ModList;
14	import net.neoforged.fml.common.Mod;
15	import net.neoforged.fml.event.lifecycle.FMLCommonSetupEvent;
16	import net.neoforged.fml.javafmlmod.FMLModContainer;
17	import net.neoforged.neoforge.common.NeoForge;
18	import net.neoforged.neoforge.event.RegisterGameTestsEvent;
19	import net.neoforged.neoforge.event.server.ServerStartedEvent;
20	import net.neoforged.neoforge.registries.NewRegistryEvent;
21	import org.apache.logging.log4j.Level;
22	import org.cyclops.cyclopscore.config.ConfigHandlerCommon;
23	import org.cyclops.cyclopscore.gametest.GameTestLoaderHelpers;
24	import org.cyclops.cyclopscore.helper.IModHelpers;
25	import org.cyclops.cyclopscore.infobook.IInfoBookRegistry;
26	import org.cyclops.cyclopscore.infobook.InfoBookRegistry;
27	import org.cyclops.cyclopscore.init.ModBaseNeoForge;
28	import org.cyclops.cyclopscore.persist.world.GlobalCounters;
29	import org.cyclops.cyclopscore.proxy.IClientProxy;
30	import org.cyclops.cyclopscore.proxy.ICommonProxy;
31	import org.cyclops.integrateddynamics.api.client.model.IVariableModelProviderRegistry;
32	import org.cyclops.integrateddynamics.api.client.render.part.IPartOverlayRendererRegistry;
33	import org.cyclops.integrateddynamics.api.client.render.valuetype.IValueTypeWorldRendererRegistry;
34	import org.cyclops.integrateddynamics.api.evaluate.operator.IOperatorRegistry;
35	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueCastRegistry;
36	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeLightLevelRegistry;
37	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeListProxyFactoryTypeRegistry;
38	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeRegistry;
39	import org.cyclops.integrateddynamics.api.ingredient.IIngredientComponentHandlerRegistry;
40	import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandlerRegistry;
41	import org.cyclops.integrateddynamics.api.logicprogrammer.ILogicProgrammerElementTypeRegistry;
42	import org.cyclops.integrateddynamics.api.network.INetworkCraftingHandlerRegistry;
43	import org.cyclops.integrateddynamics.api.part.IPartTypeRegistry;
44	import org.cyclops.integrateddynamics.api.part.aspect.IAspectRegistry;
45	import org.cyclops.integrateddynamics.capability.ingredient.IngredientComponentCapabilities;
46	import org.cyclops.integrateddynamics.capability.network.NetworkCapabilityConstructors;
47	import org.cyclops.integrateddynamics.client.render.part.PartOverlayRendererRegistry;
48	import org.cyclops.integrateddynamics.client.render.part.PartOverlayRenderers;
49	import org.cyclops.integrateddynamics.client.render.valuetype.ValueTypeWorldRendererRegistry;
50	import org.cyclops.integrateddynamics.client.render.valuetype.ValueTypeWorldRenderers;
51	import org.cyclops.integrateddynamics.command.CommandCrash;
52	import org.cyclops.integrateddynamics.command.CommandGenerateNetwork;
53	import org.cyclops.integrateddynamics.command.CommandNetworkDiagnostics;
54	import org.cyclops.integrateddynamics.command.CommandTest;
55	import org.cyclops.integrateddynamics.core.NoteBlockEventReceiver;
56	import org.cyclops.integrateddynamics.core.TickHandler;
57	import org.cyclops.integrateddynamics.core.client.model.VariableModelProviderRegistry;
58	import org.cyclops.integrateddynamics.core.client.model.VariableModelProviders;
59	import org.cyclops.integrateddynamics.core.evaluate.DelayVariableFacadeHandler;
60	import org.cyclops.integrateddynamics.core.evaluate.ProxyVariableFacadeHandler;
61	import org.cyclops.integrateddynamics.core.evaluate.operator.OperatorRegistry;
62	import org.cyclops.integrateddynamics.core.evaluate.operator.Operators;
63	import org.cyclops.integrateddynamics.core.evaluate.variable.*;
64	import org.cyclops.integrateddynamics.core.event.IntegratedDynamicsSetupEvent;
65	import org.cyclops.integrateddynamics.core.ingredient.IngredientComponentHandlerRegistry;
66	import org.cyclops.integrateddynamics.core.ingredient.IngredientComponentHandlers;
67	import org.cyclops.integrateddynamics.core.item.VariableFacadeHandlerRegistry;
68	import org.cyclops.integrateddynamics.core.logicprogrammer.LogicProgrammerElementTypeRegistry;
69	import org.cyclops.integrateddynamics.core.logicprogrammer.LogicProgrammerElementTypes;
70	import org.cyclops.integrateddynamics.core.network.NetworkCraftingHandlerRegistry;
71	import org.cyclops.integrateddynamics.core.part.PartTypeRegistry;
72	import org.cyclops.integrateddynamics.core.part.PartTypes;
73	import org.cyclops.integrateddynamics.core.part.aspect.AspectRegistry;
74	import org.cyclops.integrateddynamics.core.persist.world.LabelsWorldStorage;
75	import org.cyclops.integrateddynamics.core.persist.world.NetworkWorldStorage;
76	import org.cyclops.integrateddynamics.gametest.*;
77	import org.cyclops.integrateddynamics.gametest.integration.GameTester;
78	import org.cyclops.integrateddynamics.infobook.OnTheDynamicsOfIntegrationBook;
79	import org.cyclops.integrateddynamics.item.ItemOnTheDynamicsOfIntegrationConfig;
80	import org.cyclops.integrateddynamics.metadata.RegistryExportables;
81	import org.cyclops.integrateddynamics.part.PartTypeConnectorOmniDirectional;
82	import org.cyclops.integrateddynamics.part.aspect.Aspects;
83	import org.cyclops.integrateddynamics.proxy.ClientProxy;
84	import org.cyclops.integrateddynamics.proxy.CommonProxy;
85
86	import java.lang.reflect.Field;
87
88	/**
89	* The main mod class of IntegratedDynamics.
90	* @author rubensworks
91	*
92	*/
93	@Mod(Reference.MOD_ID)
94	public class IntegratedDynamics extends ModBaseNeoForge<IntegratedDynamics> {
95
96	/**
97	* The unique instance of this mod.
98	*/
99	public static IntegratedDynamics _instance;
100
101	public static GlobalCounters.Access globalCounters = null;	3✔
102
103	public IntegratedDynamics(IEventBus modEventBus) {
104	super(Reference.MOD_ID, (instance) -> _instance = instance, modEventBus);	8✔
105
106	// Register world storages
107	registerWorldStorage(NetworkWorldStorage.Access.getInstance(this));	4✔
108	registerWorldStorage(globalCounters = new GlobalCounters.Access(this));	8✔
109	registerWorldStorage(LabelsWorldStorage.Access.getInstance(this));	4✔
110
111	getRegistryManager().addRegistry(IVariableFacadeHandlerRegistry.class, VariableFacadeHandlerRegistry.getInstance());	5✔
112	getRegistryManager().addRegistry(IValueTypeRegistry.class, ValueTypeRegistry.getInstance());	5✔
113	getRegistryManager().addRegistry(IValueCastRegistry.class, ValueCastRegistry.getInstance());	5✔
114	getRegistryManager().addRegistry(IValueTypeListProxyFactoryTypeRegistry.class, ValueTypeListProxyFactoryTypeRegistry.getInstance());	5✔
115	getRegistryManager().addRegistry(IValueTypeLightLevelRegistry.class, ValueTypeLightLevelRegistry.getInstance());	5✔
116	getRegistryManager().addRegistry(IPartTypeRegistry.class, PartTypeRegistry.getInstance());	5✔
117	getRegistryManager().addRegistry(IAspectRegistry.class, AspectRegistry.getInstance());	5✔
118	getRegistryManager().addRegistry(IOperatorRegistry.class, OperatorRegistry.getInstance());	5✔
119	getRegistryManager().addRegistry(ILogicProgrammerElementTypeRegistry.class, LogicProgrammerElementTypeRegistry.getInstance());	5✔
120	if(getModHelpers().getMinecraftHelpers().isClientSide()) {	5!
121	getRegistryManager().addRegistry(IPartOverlayRendererRegistry.class, PartOverlayRendererRegistry.getInstance());	×
122	getRegistryManager().addRegistry(IValueTypeWorldRendererRegistry.class, ValueTypeWorldRendererRegistry.getInstance());	×
123	getRegistryManager().addRegistry(IVariableModelProviderRegistry.class, VariableModelProviderRegistry.getInstance());	×
124	}
125
126	getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class).registerHandler(ProxyVariableFacadeHandler.getInstance());	7✔
127	getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class).registerHandler(DelayVariableFacadeHandler.getInstance());	7✔
128	getRegistryManager().addRegistry(IInfoBookRegistry.class, new InfoBookRegistry());	7✔
129	getRegistryManager().addRegistry(IIngredientComponentHandlerRegistry.class, IngredientComponentHandlerRegistry.getInstance());	5✔
130	getRegistryManager().addRegistry(INetworkCraftingHandlerRegistry.class, NetworkCraftingHandlerRegistry.getInstance());	5✔
131
132	// Preload parts, so we force their blocks and items to be registered
133	PartTypes.load();	1✔
134
135	modEventBus.addListener(EventPriority.LOWEST, IngredientComponentHandlers::onIngredientComponentsPopulated);	4✔
136	modEventBus.addListener(this::onRegistriesCreate);	4✔
137	modEventBus.register(new NetworkCapabilityConstructors());	5✔
138	modEventBus.addListener(this::registerIntegrationGameTests);	4✔
139
140	NeoForge.EVENT_BUS.addListener(this::onServerStartedLoadedGroups);	4✔
141	NeoForge.EVENT_BUS.register(TickHandler.getInstance());	3✔
142	NeoForge.EVENT_BUS.register(NoteBlockEventReceiver.getInstance());	3✔
143	}	1✔
144
145	public void onRegistriesCreate(NewRegistryEvent event) {
146	IngredientComponentCapabilities.load();	1✔
147	}	1✔
148
149	@Override
150	protected LiteralArgumentBuilder<CommandSourceStack> constructBaseCommand(Commands.CommandSelection selection, CommandBuildContext context) {
151	LiteralArgumentBuilder<CommandSourceStack> root = super.constructBaseCommand(selection, context);	5✔
152
153	root.then(CommandCrash.make());	4✔
154	root.then(CommandGenerateNetwork.make());	4✔
155	root.then(CommandNetworkDiagnostics.make());	4✔
156	root.then(CommandTest.make());	4✔
157
158	return root;	2✔
159	}
160
161	@Override
162	protected void setup(FMLCommonSetupEvent event) {
163	ValueTypes.load();	1✔
164	IngredientComponentHandlers.load();	1✔
165	ValueCastMappings.load();	1✔
166	ValueTypeLightLevels.load();	1✔
167	ValueTypeListProxyFactories.load();	1✔
168	Operators.load();	1✔
169	Aspects.load();	1✔
170	PartTypes.register();	1✔
171	LogicProgrammerElementTypes.load();	1✔
172	RegistryExportables.load();	1✔
173
174	// Register info book
175	putGenericReference(ModBaseNeoForge.REFKEY_INFOBOOK_REWARDS, ItemOnTheDynamicsOfIntegrationConfig.bookRewards);	5✔
176	getRegistryManager().getRegistry(IInfoBookRegistry.class).registerInfoBook(	6✔
177	OnTheDynamicsOfIntegrationBook.getInstance(), "/data/" + Reference.MOD_ID + "/info/on_the_dynamics_of_integration.xml");	2✔
178
179	IntegratedDynamicsSetupEvent integratedDynamicsSetupEvent = new IntegratedDynamicsSetupEvent(this.getContainer());	6✔
180	ModList.get().forEachModContainer((name, container) -> {	4✔
181	if (container instanceof FMLModContainer fmlModContainer) {	6✔
182	fmlModContainer.getEventBus().post(integratedDynamicsSetupEvent);	5✔
183	}
184	});	1✔
185
186	if(IModHelpers.get().getMinecraftHelpers().isClientSide()) {	4!
187	PartOverlayRenderers.load();	×
188	ValueTypeWorldRenderers.load();	×
189	VariableModelProviders.load();	×
190	}
191
192	super.setup(event);	3✔
193	}	1✔
194
195	protected void onServerStartedLoadedGroups(ServerStartedEvent event) {
196	PartTypeConnectorOmniDirectional.LOADED_GROUPS.onStartedEvent(event);	3✔
197	}	1✔
198
199	@Override
200	protected IClientProxy constructClientProxy() {
201	return new ClientProxy();	×
202	}
203
204	@Override
205	protected ICommonProxy constructCommonProxy() {
206	return new CommonProxy();	4✔
207	}
208
209	@Override
210	protected CreativeModeTab.Builder constructDefaultCreativeModeTab(CreativeModeTab.Builder builder) {
211	return super.constructDefaultCreativeModeTab(builder)	5✔
212	.icon(() -> new ItemStack(RegistryEntries.ITEM_CABLE));	1✔
213	}
214
215	@Override
216	protected void onConfigsRegister(ConfigHandlerCommon configHandler) {
217	super.onConfigsRegister(configHandler);	3✔
218
219	configHandler.addConfigurable(new GeneralConfig());	6✔
220	Configs.registerBlocks(configHandler);	2✔
221	}	1✔
222
223	@Override
224	public Class<?>[] getGameTestClasses() {
225	return new Class[]{	123✔
226	GameTestsAdvancements.class,
227	GameTestsAspectsReadAudio.class,
228	GameTestsAspectsReadBlock.class,
229	GameTestsAspectsReadEntity.class,
230	GameTestsAspectsReadExtraDimensional.class,
231	GameTestsAspectsReadFluid.class,
232	GameTestsAspectsReadInventory.class,
233	GameTestsAspectsReadMachine.class,
234	GameTestsAspectsReadNetwork.class,
235	GameTestsAspectsReadRedstone.class,
236	GameTestsAspectsReadWorld.class,
237	GameTestsAspectsWriteRedstone.class,
238	GameTestsBattery.class,
239	GameTestsCombinedAspects.class,
240	GameTestsDelayer.class,
241	GameTestsDryingBasin.class,
242	GameTestsFacades.class,
243	GameTestsFluids.class,
244	GameTestsFuzzing.class,
245	GameTestsGenerator.class,
246	GameTestsMaterializer.class,
247	GameTestsMechanicalDryingBasin.class,
248	GameTestsMechanicalSqueezer.class,
249	GameTestsNetwork.class,
250	GameTestsOffsets.class,
251	GameTestsParts.class,
252	GameTestsPerformance.class,
253	GameTestsProxy.class,
254	GameTestsSqueezer.class,
255	GameTestsWrench.class,
256	};
257	}
258
259	protected void registerIntegrationGameTests(RegisterGameTestsEvent event) {
260	if (!GameTestLoaderHelpers.areGameTestsEnabled(getModId())) {	4!
261	return;	×
262	}
263	try {
264	Field field = RegisterGameTestsEvent.class.getDeclaredField("environmentsRegistry");	4✔
265	field.setAccessible(true);	3✔
266	Registry<TestEnvironmentDefinition<?>> testEnvironmentRegistry = (Registry<TestEnvironmentDefinition<?>>) field.get(event);	5✔
267	GameTester.registerCommonTests(getModId(), event::registerTest, testEnvironmentRegistry);	9✔
268	GameTestsFuzzing.registerCommonTests(getModId(), event::registerTest, testEnvironmentRegistry);	9✔
269	} catch (NoSuchFieldException \| IllegalAccessException e) {	×
270	throw new RuntimeException(e);	×
271	}	1✔
272	}	1✔
273
274	/**
275	* Log a new info message for this mod.
276	* @param message The message to show.
277	*/
278	public static void clog(String message) {
279	IntegratedDynamics._instance.log(Level.INFO, message);	4✔
280	}	1✔
281
282	/**
283	* Log a new message of the given level for this mod.
284	* @param level The level in which the message must be shown.
285	* @param message The message to show.
286	*/
287	public static void clog(Level level, String message) {
288	IntegratedDynamics._instance.log(level, message);	4✔
289	}	1✔
290	}

CyclopsMC / IntegratedDynamics / 24313951665

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