Neoforge dev/1.21.1

build.gradle

@@ -94,7 +94,7 @@ repositories {
 
 dependencies {
     compileOnly "software.bernie.geckolib:geckolib-neoforge-${minecraft_version}:${geckolib_version}"
-    localRuntime "software.bernie.geckolib:geckolib-neoforge-${minecraft_version}:${geckolib_version}"
+//    localRuntime "software.bernie.geckolib:geckolib-neoforge-${minecraft_version}:${geckolib_version}"
 }
 
 tasks.withType(ProcessResources).configureEach {

gradle.properties

@@ -31,7 +31,7 @@ mod_name=ParticleStorm
 # The license of the mod. Review your options at https://choosealicense.com/. All Rights Reserved is the default.
 mod_license=LGPL-3.0
 # The mod version. See https://semver.org/
-mod_version=1.0.8.7
+mod_version=1.1.4
 # The group ID for the mod. It is only important when publishing as an artifact to a Maven repository.
 # This should match the base package used for the mod sources.
 # See https://maven.apache.org/guides/mini/guide-naming-conventions.html
@@ -41,9 +41,9 @@ mod_authors=Westernat
 # The description of the mod. This is a simple multiline text string that is used for display purposes in the mod list.
 mod_description=Uses a Bedrock Edition JSON format for particle effects.
 
-geckolib_version=4.7.5.1
+geckolib_version=4.8.2
 
-# systemProp.http.proxyHost=localhost
-# systemProp.http.proxyPort=7890
-# systemProp.https.proxyHost=localhost
-# systemProp.https.proxyPort=7890
+#systemProp.http.proxyHost=localhost
+#systemProp.http.proxyPort=7890
+#systemProp.https.proxyHost=localhost
+#systemProp.https.proxyPort=7890

src/main/java/org/mesdag/particlestorm/PSGameClient.java

@@ -14,7 +14,6 @@
 import net.minecraft.client.renderer.texture.TextureAtlas;
 import net.minecraft.client.renderer.texture.TextureManager;
 import net.minecraft.util.Mth;
-import net.minecraft.world.entity.EntityType;
 import net.neoforged.api.distmarker.Dist;
 import net.neoforged.bus.api.SubscribeEvent;
 import net.neoforged.fml.common.EventBusSubscriber;
@@ -25,14 +24,11 @@
 import net.neoforged.neoforge.client.event.RegisterClientReloadListenersEvent;
 import net.neoforged.neoforge.client.event.RenderLevelStageEvent;
 import net.neoforged.neoforge.common.NeoForge;
-import org.jetbrains.annotations.NotNull;
 import org.mesdag.particlestorm.api.IComponent;
 import org.mesdag.particlestorm.api.IEventNode;
-import org.mesdag.particlestorm.api.geckolib.ExampleBlockEntityRenderer;
-import org.mesdag.particlestorm.api.geckolib.ReplacedCreeperRenderer;
+import org.mesdag.particlestorm.api.geckolib.GeckoLibHelper;
 import org.mesdag.particlestorm.data.component.*;
 import org.mesdag.particlestorm.data.event.*;
-import org.mesdag.particlestorm.mixin.ParticleEngineAccessor;
 import org.mesdag.particlestorm.particle.MolangParticleLoader;
 import org.mesdag.particlestorm.particle.ParticleEmitter;
 
@@ -41,7 +37,7 @@ public final class PSGameClient {
     public static final MolangParticleLoader LOADER = new MolangParticleLoader();
     public static final ParticleRenderType PARTICLE_ADD = new ParticleRenderType() {
         @Override
-        public BufferBuilder begin(Tesselator tesselator, @NotNull TextureManager textureManager) {
+        public BufferBuilder begin(Tesselator tesselator, TextureManager textureManager) {
             RenderSystem.enableDepthTest();
             Minecraft.getInstance().gameRenderer.lightTexture().turnOnLightLayer();
             RenderSystem.depthMask(false);
@@ -57,10 +53,9 @@ public String toString() {
     };
 
     @SubscribeEvent
-    public static void registerRenderers(final EntityRenderersEvent.RegisterRenderers event) {
+    public static void registerRenderers(EntityRenderersEvent.RegisterRenderers event) {
         if (ParticleStorm.DEBUG) {
-            event.registerBlockEntityRenderer(ParticleStorm.TEST_ENTITY.get(), ExampleBlockEntityRenderer::new);
-            event.registerEntityRenderer(EntityType.CREEPER, ReplacedCreeperRenderer::new);
+            GeckoLibHelper.registerRenderers(event);
         }
     }
 
@@ -85,7 +80,7 @@ private static void tick(ClientTickEvent.Pre event) {
         LocalPlayer localPlayer = minecraft.player;
         if (localPlayer == null) {
             LOADER.removeAll();
-        } else if (!minecraft.isPaused() && !localPlayer.level().tickRateManager().isFrozen()) {
+        } else if (!minecraft.isPaused() && localPlayer.level().tickRateManager().runsNormally()) {
             LOADER.tick(localPlayer);
         }
     }
@@ -97,14 +92,14 @@ private static void renderLevelStage(RenderLevelStageEvent event) {
             float partialTicks = event.getPartialTick().getGameTimeDeltaPartialTick(true);
             PoseStack poseStack = event.getPoseStack();
             MultiBufferSource.BufferSource bufferSource = minecraft.renderBuffers().bufferSource();
-            for (ParticleEmitter emitter : LOADER.emitters.values()) {
+            for (ParticleEmitter emitter : LOADER.getEmitters()) {
                 double x = Mth.lerp(partialTicks, emitter.posO.x, emitter.pos.x);
                 double y = Mth.lerp(partialTicks, emitter.posO.y, emitter.pos.y);
                 double z = Mth.lerp(partialTicks, emitter.posO.z, emitter.pos.z);
-                DebugRenderer.renderFloatingText(poseStack, bufferSource, emitter.getPreset().option.getId().toString(), x, y + 0.5, z, 0xFFFFFF);
+                DebugRenderer.renderFloatingText(poseStack, bufferSource, emitter.particleId.toString(), x, y + 0.5, z, 0xFFFFFF);
                 DebugRenderer.renderFloatingText(poseStack, bufferSource, "id: " + emitter.id, x, y + 0.3, z, 0xFFFFFF);
-                int maxNum = ((ParticleEngineAccessor) minecraft.particleEngine).trackedParticleCounts().getInt(emitter.particleGroup);
-                DebugRenderer.renderFloatingText(poseStack, bufferSource, "particles: " + maxNum, x, y + 0.1, z, maxNum == emitter.particleGroup.getLimit() ? 0xFF0000 : 0xFFFFFF);
+                int maxNum = minecraft.particleEngine.trackedParticleCounts.getInt(emitter.particleGroup);
+                DebugRenderer.renderFloatingText(poseStack, bufferSource, "particles: " + maxNum, x, y + 0.1, z, maxNum >= emitter.particleGroup.getLimit() ? 0xFF0000 : 0xFFFFFF);
                 Camera camera = event.getCamera();
                 double d0 = camera.getPosition().x;
                 double d1 = camera.getPosition().y;
@@ -169,5 +164,6 @@ private static void registerEventNodes() {
         IEventNode.register("particle_effect", ParticleEffect.CODEC.codec());
         IEventNode.register("sound_effect", SoundEffect.CODEC.codec());
         IEventNode.register("expression", NodeMolangExp.CODEC);
+        IEventNode.register("log", EventLog.CODEC);
     }
 }

src/main/java/org/mesdag/particlestorm/PSModClient.java

@@ -0,0 +1,17 @@
+package org.mesdag.particlestorm;
+
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
+import org.mesdag.particlestorm.api.RegisterCustomParticleTypeEvent;
+import org.mesdag.particlestorm.particle.MolangParticleInstance;
+
+@EventBusSubscriber(modid = ParticleStorm.MODID, bus = EventBusSubscriber.Bus.MOD, value = Dist.CLIENT)
+public final class PSModClient {
+    @SubscribeEvent
+    public static void registerCustomParticleType(RegisterCustomParticleTypeEvent event) {
+        event.registerWithSprites(ParticleStorm.MOLANG, (emitter, particlePreset, level, x, y, z, sprites) ->
+                new MolangParticleInstance(particlePreset, level, x, y, z, sprites)
+        );
+    }
+}

src/main/java/org/mesdag/particlestorm/ParticleStorm.java

@@ -3,18 +3,17 @@
 import com.mojang.datafixers.util.Either;
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.MapCodec;
+import io.netty.buffer.ByteBuf;
 import net.minecraft.core.particles.ParticleType;
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.nbt.CompoundTag;
-import net.minecraft.network.RegistryFriendlyByteBuf;
 import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.block.entity.BlockEntityType;
 import net.neoforged.bus.api.IEventBus;
 import net.neoforged.fml.ModContainer;
 import net.neoforged.fml.common.Mod;
+import net.neoforged.fml.loading.LoadingModList;
 import net.neoforged.neoforge.common.NeoForge;
 import net.neoforged.neoforge.event.RegisterCommandsEvent;
 import net.neoforged.neoforge.event.entity.player.PlayerEvent;
@@ -23,8 +22,7 @@
 import net.neoforged.neoforge.network.registration.PayloadRegistrar;
 import net.neoforged.neoforge.registries.DeferredHolder;
 import net.neoforged.neoforge.registries.DeferredRegister;
-import org.jetbrains.annotations.NotNull;
-import org.mesdag.particlestorm.api.geckolib.TestBlock;
+import org.mesdag.particlestorm.api.geckolib.GeckoLibHelper;
 import org.mesdag.particlestorm.network.EmitterAttachPacketS2C;
 import org.mesdag.particlestorm.network.EmitterCreationPacketS2C;
 import org.mesdag.particlestorm.network.EmitterRemovalPacket;
@@ -44,29 +42,18 @@
 public final class ParticleStorm {
     public static final String MODID = "particlestorm";
     public static final Logger LOGGER = LoggerFactory.getLogger("ParticleStorm");
-    public static final boolean DEBUG = Boolean.getBoolean("particlestorm.debug");
+    public static final boolean DEBUG = Boolean.getBoolean("particlestorm.debug") && LoadingModList.get().getModFileById("geckolib") != null;
 
-    public static final DeferredRegister<ParticleType<?>> PARTICLE = DeferredRegister.create(BuiltInRegistries.PARTICLE_TYPE, MODID);
-    public static final DeferredHolder<ParticleType<?>, ParticleType<MolangParticleOption>> MOLANG = PARTICLE.register("molang", () -> new ParticleType<MolangParticleOption>(false) {
-        @Override
-        public @NotNull MapCodec<MolangParticleOption> codec() {
-            return MolangParticleOption.codec(this);
-        }
-
-        @Override
-        public @NotNull StreamCodec<? super RegistryFriendlyByteBuf, MolangParticleOption> streamCodec() {
-            return MolangParticleOption.streamCodec(this);
-        }
-    });
-    public static final Codec<List<String>> STRING_LIST_CODEC = Codec.either(Codec.STRING, Codec.list(Codec.STRING)).xmap(
+    private static final DeferredRegister<ParticleType<?>> REGISTER = DeferredRegister.create(BuiltInRegistries.PARTICLE_TYPE, MODID);
+    public static final DeferredHolder<ParticleType<?>, ParticleType<MolangParticleOption>> MOLANG = registerParticleType(REGISTER, "molang");
+    public static final Codec<List<String>> STRING_LIST_CODEC = Codec.either(Codec.STRING, Codec.STRING.listOf()).xmap(
             either -> either.map(Collections::singletonList, Function.identity()),
             l -> l.size() == 1 ? Either.left(l.getFirst()) : Either.right(l)
     );
-    public static DeferredHolder<BlockEntityType<?>, BlockEntityType<TestBlock.Entity>> TEST_ENTITY;
 
     public ParticleStorm(IEventBus bus, ModContainer container) {
         PSClientConfigs.register(container);
-        PARTICLE.register(bus);
+        REGISTER.register(bus);
         registerGeoTest(bus);
         bus.addListener(ParticleStorm::registerPayloadHandlers);
         NeoForge.EVENT_BUS.addListener(ParticleStorm::registerCommands);
@@ -75,26 +62,10 @@ public ParticleStorm(IEventBus bus, ModContainer container) {
 
     private static void registerPayloadHandlers(RegisterPayloadHandlersEvent event) {
         PayloadRegistrar registrar = event.registrar("1");
-        registrar.playToClient(
-                EmitterCreationPacketS2C.TYPE,
-                EmitterCreationPacketS2C.STREAM_CODEC,
-                EmitterCreationPacketS2C::handle
-        );
-        registrar.playToClient(
-                EmitterAttachPacketS2C.TYPE,
-                EmitterAttachPacketS2C.STREAM_CODEC,
-                EmitterAttachPacketS2C::handle
-        );
-        registrar.playBidirectional(
-                EmitterRemovalPacket.TYPE,
-                EmitterRemovalPacket.STREAM_CODEC,
-                EmitterRemovalPacket::handle
-        );
-        registrar.playBidirectional(
-                EmitterSynchronizePacket.TYPE,
-                EmitterSynchronizePacket.STREAM_CODEC,
-                EmitterSynchronizePacket::handle
-        );
+        registrar.playToClient(EmitterCreationPacketS2C.TYPE, EmitterCreationPacketS2C.STREAM_CODEC, EmitterCreationPacketS2C::handle);
+        registrar.playToClient(EmitterAttachPacketS2C.TYPE, EmitterAttachPacketS2C.STREAM_CODEC, EmitterAttachPacketS2C::handle);
+        registrar.playBidirectional(EmitterRemovalPacket.TYPE, EmitterRemovalPacket.STREAM_CODEC, EmitterRemovalPacket::handle);
+        registrar.playBidirectional(EmitterSynchronizePacket.TYPE, EmitterSynchronizePacket.STREAM_CODEC, EmitterSynchronizePacket::handle);
     }
 
     private static void registerCommands(RegisterCommandsEvent event) {
@@ -115,16 +86,25 @@ private static void playerLoggedIn(PlayerEvent.PlayerLoggedInEvent event) {
 
     private static void registerGeoTest(IEventBus bus) {
         if (DEBUG) {
-            DeferredRegister<Block> BLOCK = DeferredRegister.create(BuiltInRegistries.BLOCK, MODID);
-            DeferredRegister<BlockEntityType<?>> ENTITY = DeferredRegister.create(BuiltInRegistries.BLOCK_ENTITY_TYPE, MODID);
-            DeferredHolder<Block, Block> TEST = BLOCK.register("test_block", TestBlock::new);
-            TEST_ENTITY = ENTITY.register("test_entity", () -> BlockEntityType.Builder.of(TestBlock.Entity::new, TEST.get()).build(null));
-            BLOCK.register(bus);
-            ENTITY.register(bus);
+            GeckoLibHelper.registerStuffs(bus);
         }
     }
 
     public static ResourceLocation asResource(String path) {
         return ResourceLocation.fromNamespaceAndPath(MODID, path);
     }
+
+    public static DeferredHolder<ParticleType<?>, ParticleType<MolangParticleOption>> registerParticleType(DeferredRegister<ParticleType<?>> register, String name) {
+        return register.register(name, () -> new ParticleType<>(false) {
+            @Override
+            public MapCodec<MolangParticleOption> codec() {
+                return MolangParticleOption.CODEC;
+            }
+
+            @Override
+            public StreamCodec<ByteBuf, MolangParticleOption> streamCodec() {
+                return MolangParticleOption.STREAM_CODEC;
+            }
+        });
+    }
 }

src/main/java/org/mesdag/particlestorm/api/IComponent.java

@@ -23,6 +23,7 @@ static void register(String vanillaPath, Codec<? extends IComponent> codec) {
 
     List<MolangExp> getAllMolangExp();
 
+    /// @return <= 0 means early initialize
     default int order() {
         return 1000;
     }

src/main/java/org/mesdag/particlestorm/api/IEventNode.java

@@ -19,6 +19,7 @@ static <T extends IEventNode> Codec<T> getCodec(String name) {
         return codec;
     }
 
+    @SuppressWarnings("unchecked")
     static void register(String name, Codec<? extends IEventNode> codec) {
         MAP.put(name, (Codec<IEventNode>) codec);
     }