change: Slider signal no longer does directional stuff

Sad, but i couldn't get it to work properly

src/main/java/net/zepalesque/redux/Redux.java

@@ -36,7 +36,7 @@
 import net.zepalesque.redux.loot.modifer.ReduxLootModifiers;
 import net.zepalesque.redux.network.packet.AerjumpPacket;
 import net.zepalesque.redux.network.packet.ReduxPlayerSyncPacket;
-import net.zepalesque.redux.network.packet.SliderSignalSyncPacket;
+import net.zepalesque.redux.network.packet.SliderSignalPacket;
 import net.zepalesque.redux.pack.PackUtils;
 import net.zepalesque.redux.pack.ReduxPackConfig;
 import net.zepalesque.redux.recipe.ReduxRecipes;
@@ -123,7 +123,7 @@ public void registerPackets(RegisterPayloadHandlersEvent event) {
         registrar.playToClient(AerjumpPacket.Accepted.TYPE, AerjumpPacket.Accepted.STREAM_CODEC, AerjumpPacket.Accepted::execute);
         registrar.playToClient(AerjumpPacket.Particles.TYPE, AerjumpPacket.Particles.STREAM_CODEC, AerjumpPacket.Particles::execute);
         registrar.playBidirectional(ReduxPlayerSyncPacket.TYPE, ReduxPlayerSyncPacket.STREAM_CODEC, ReduxPlayerSyncPacket::execute);
-        registrar.playToClient(SliderSignalSyncPacket.TYPE, SliderSignalSyncPacket.STREAM_CODEC, SliderSignalSyncPacket::execute);
+        registrar.playToClient(SliderSignalPacket.TYPE, SliderSignalPacket.STREAM_CODEC, SliderSignalPacket::execute);
     }
 
     private void registerDataMaps(RegisterDataMapTypesEvent event) {

src/main/java/net/zepalesque/redux/attachment/SliderSignalAttachment.java

@@ -1,88 +1,46 @@
 package net.zepalesque.redux.attachment;
 
 import com.aetherteam.aether.entity.monster.dungeon.boss.Slider;
-import com.aetherteam.nitrogen.attachment.INBTSynchable;
-import com.aetherteam.nitrogen.network.packet.SyncPacket;
-import net.minecraft.core.Direction;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.sounds.SoundSource;
-import net.minecraft.world.entity.LivingEntity;
-import net.minecraft.world.phys.Vec3;
+import net.neoforged.neoforge.network.PacketDistributor;
 import net.zepalesque.redux.client.audio.ReduxSounds;
-import net.zepalesque.redux.network.packet.SliderSignalSyncPacket;
-import org.apache.commons.lang3.tuple.Triple;
+import net.zepalesque.redux.network.packet.SliderSignalPacket;
 import org.jetbrains.annotations.NotNull;
-import oshi.util.tuples.Quintet;
-
-import java.util.Map;
-import java.util.function.Consumer;
-import java.util.function.Supplier;
-
-public class SliderSignalAttachment implements INBTSynchable {
-
-    private final Map<String, Triple<INBTSynchable.Type, Consumer<Object>, Supplier<Object>>> synchableFunctions = Map.ofEntries(
-            Map.entry("signal_tick", Triple.of(INBTSynchable.Type.INT, (object) -> this.setSignalTick((int) object), this::getSignalTick)),
-            Map.entry("move_direction_ordinal", Triple.of(INBTSynchable.Type.INT, (object) -> this.setMoveDirection((int) object), this::getMoveDirectionIndex))
-    );
-
-    protected int signalTick = 0, moveDirIndex = -1;
 
+// Client-Side
+public class SliderSignalAttachment {
 
+    protected int signalTick = 0;
 
     public void onUpdate(Slider slider) {
         this.tickSignal(slider);
     }
 
     protected void tickSignal(Slider slider) {
-        if (this.signalTick > 0) {
-            if (this.shouldGlow(slider) && (this.moveDirIndex != -1 || slider.isCritical()))
-                slider.level().playSound(null, slider.getX(), slider.getY(), slider.getZ(), ReduxSounds.SLIDER_SIGNAL, SoundSource.HOSTILE, 1F, 1F);
+        if (this.signalTick > 0 && slider.level().isClientSide()) {
+            if (this.signalTick == 1) playSound(slider);
             this.signalTick--;
-        } else if (this.moveDirIndex != -1) {
-            this.moveDirIndex = -1;
         }
     }
 
     public boolean shouldGlow(Slider slider) {
         return this.signalTick == 7 || this.signalTick == 1;
     }
 
-    public void doBeep(Slider slider) {
-        if (!slider.level().isClientSide() && this.getSignalTick() == 0) {
-            this.setSynched(slider.getId(), Direction.NEAR, "signal_tick", 8, extraForNear(slider));
-        }
+    public static void sendPacket(Slider slider) {
+        PacketDistributor.sendToPlayersNear((ServerLevel) slider.level(), null, slider.getX(), slider.getY(), slider.getZ(), 50D, new SliderSignalPacket(slider.getId()));
     }
 
-    public static Quintet<Double, Double, Double, Double, ServerLevel> extraForNear(Slider slider) {
-        return new Quintet<>(slider.getX(), slider.getY(), slider.getZ(), 50D, (ServerLevel) slider.level());
-    }
-
-
-    public void syncMoveDirection(Slider slider) {
-        if (!slider.level().isClientSide()) {
-            Vec3 targetPoint = this.targetVector(slider);
-            if (targetPoint != null) {
-                int dir = this.getMoveDirection(slider, targetPoint);
-                this.setSynched(slider.getId(), Direction.NEAR, "move_direction_ordinal", dir, extraForNear(slider));
-            }
-        }
-    }
-
-    private int getMoveDirection(Slider slider, Vec3 targetPoint) {
-        net.minecraft.core.Direction moveDir = slider.getMoveDirection();
-
-        if (moveDir == null) { // Checks if the direction has changed.
-            double x = targetPoint.x - slider.getX();
-            double y = targetPoint.y - slider.getY();
-            double z = targetPoint.z - slider.getZ();
-            moveDir = Slider.calculateDirection(x, y, z);
+    public void doBeep(Slider slider) {
+        if (this.getSignalTick() == 0) {
+            this.setSignalTick(7);
+            playSound(slider);
         }
-        return moveDir.ordinal();
     }
 
-    private Vec3 targetVector(Slider slider) {
-        LivingEntity target = slider.getTarget();
-        return target == null ? null : target.position();
+    protected void playSound(Slider slider) {
+        slider.level().playSound(null, slider.getX(), slider.getY(), slider.getZ(), ReduxSounds.SLIDER_SIGNAL, SoundSource.HOSTILE, 1F, 1F);
     }
 
     public static @NotNull SliderSignalAttachment get(@NotNull Slider slider) {
@@ -96,25 +54,4 @@ public int getSignalTick() {
     public void setSignalTick(int signalTick) {
         this.signalTick = signalTick;
     }
-
-
-
-    public int getMoveDirectionIndex() {
-        return this.moveDirIndex;
-    }
-
-    public void setMoveDirection(int ordinal) {
-        this.moveDirIndex = ordinal;
-    }
-
-
-    @Override
-    public Map<String, Triple<Type, Consumer<Object>, Supplier<Object>>> getSynchableFunctions() {
-        return synchableFunctions;
-    }
-
-    @Override
-    public SyncPacket getSyncPacket(int entityID, String key, Type type, Object value) {
-        return new SliderSignalSyncPacket(entityID, key, type, value);
-    }
 }

src/main/java/net/zepalesque/redux/client/renderer/entity/layer/SliderSignalLayer.java

@@ -17,9 +17,7 @@
 
 public class SliderSignalLayer extends RenderLayer<Slider, SliderModel> {
 
-    private static final RenderType[] DIRECTIONAL = ArrayUtil.generateContents(new RenderType[6], i ->
-            RenderType.eyes(ResourceLocation.fromNamespaceAndPath(Aether.MODID, "textures/entity/mobs/slider/slider_signal_" + Direction.values()[i].getName() + ".png")));
-
+    private static final RenderType NORMAL = RenderType.eyes(ResourceLocation.fromNamespaceAndPath(Aether.MODID, "textures/entity/mobs/slider/slider_awake_critical_glow.png"));
     private static final RenderType CRITICAL = RenderType.eyes(ResourceLocation.fromNamespaceAndPath(Aether.MODID, "textures/entity/mobs/slider/slider_awake_glow.png"));
 
     public SliderSignalLayer(RenderLayerParent<Slider, SliderModel> pRenderer) {
@@ -30,11 +28,9 @@ public SliderSignalLayer(RenderLayerParent<Slider, SliderModel> pRenderer) {
     public void render(PoseStack poseStack, MultiBufferSource buffer, int packedLight, Slider slider, float limbSwing, float limbSwingAmount, float partialTicks, float ageInTicks, float netHeadYaw, float headPitch) {
         SliderSignalAttachment signal = SliderSignalAttachment.get(slider);
         if (slider.isAwake() && signal.shouldGlow(slider)) {
-            if (signal.getMoveDirectionIndex() != -1) {
-                RenderType renderType = slider.isCritical() ? CRITICAL : DIRECTIONAL[signal.getMoveDirectionIndex()];
-                VertexConsumer consumer = buffer.getBuffer(renderType);
-                this.getParentModel().renderToBuffer(poseStack, consumer, 15728640, OverlayTexture.NO_OVERLAY);
-            }
+            RenderType renderType = slider.isCritical() ? CRITICAL : NORMAL;
+            VertexConsumer consumer = buffer.getBuffer(renderType);
+            this.getParentModel().renderToBuffer(poseStack, consumer, 15728640, OverlayTexture.NO_OVERLAY);
         }
     }
 }

src/main/java/net/zepalesque/redux/event/listener/MobListener.java

@@ -35,7 +35,7 @@ public static void onTick(EntityTickEvent.Post event) {
         if (entity instanceof Player player) {
             ReduxPlayerAttachment attachment = ReduxPlayerAttachment.get(player);
             attachment.onUpdate(player);
-        } else if (entity instanceof Slider slider) {
+        } else if (entity instanceof Slider slider && entity.level().isClientSide()) {
             SliderSignalAttachment attachment = SliderSignalAttachment.get(slider);
             attachment.onUpdate(slider);
         }

src/main/java/net/zepalesque/redux/mixin/mixins/common/entity/SliderMixin.java

@@ -28,27 +28,14 @@ public abstract class SliderMixin extends LivingEntityMixin {
 
     @Inject(method = "calculateMoveDelay", at = @At("HEAD"), cancellable = true)
     protected void redux$calculateMoveDelay(CallbackInfoReturnable<Integer> cir) {
-        int adjusted = this.isCritical() ? 5 + this.getRandom().nextInt(6) : 8 + this.getRandom().nextInt(7);
+        int adjusted = this.isCritical() ? 3 + this.getRandom().nextInt(8) : 7 + this.getRandom().nextInt(8);
         cir.setReturnValue(adjusted);
     }
 
-
-    @Inject(method = "setMoveDirection", at = @At("TAIL"))
-    protected void redux$setMoveDirection(Direction moveDirection, CallbackInfo ci) {
-//        if (moveDirection != null) {
-//            SliderSignalAttachment signal = SliderSignalAttachment.get((Slider) (Object) this);
-//            signal.syncMoveDirection((Slider) (Object) this);
-//        }
-    }
-
     @Inject(method = "customServerAiStep", at = @At("TAIL"))
     protected void redux$customServerAiStep(CallbackInfo ci) {
-        SliderSignalAttachment signal = SliderSignalAttachment.get((Slider) (Object) this);
-        if (!this.isCritical() && this.moveDelay == 8 || this.isCritical() && this.moveDelay == 4) {
-            signal.doBeep((Slider) (Object) this);
-            signal.syncMoveDirection((Slider) (Object) this);
-        } else if (this.moveDelay == 2) {
-            signal.syncMoveDirection((Slider) (Object) this);
+        if (!this.isCritical() && this.moveDelay == 7 || this.isCritical() && this.moveDelay == 3) {
+            SliderSignalAttachment.sendPacket((Slider) (Object) this);
         }
     }
 }

src/main/java/net/zepalesque/redux/network/packet/SliderSignalPacket.java

@@ -0,0 +1,57 @@
+package net.zepalesque.redux.network.packet;
+
+import com.aetherteam.aether.entity.AetherEntityTypes;
+import com.aetherteam.aether.entity.monster.dungeon.boss.Slider;
+import com.aetherteam.nitrogen.attachment.INBTSynchable;
+import com.aetherteam.nitrogen.network.packet.SyncEntityPacket;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.world.entity.Entity;
+import net.neoforged.neoforge.attachment.AttachmentType;
+import net.neoforged.neoforge.network.handling.IPayloadContext;
+import net.zepalesque.redux.Redux;
+import net.zepalesque.redux.attachment.ReduxDataAttachments;
+import net.zepalesque.redux.attachment.SliderSignalAttachment;
+import oshi.util.tuples.Quartet;
+
+import java.util.function.Supplier;
+
+public record SliderSignalPacket(int mobID) implements CustomPacketPayload {
+
+    public static final Type<SliderSignalPacket> TYPE = new Type<>(Redux.loc("slider_signal"));
+
+    public static final StreamCodec<RegistryFriendlyByteBuf, SliderSignalPacket> STREAM_CODEC = CustomPacketPayload.codec(
+            SliderSignalPacket::write,
+            SliderSignalPacket::decode);
+
+    public void write(FriendlyByteBuf buf) {
+        buf.writeInt(this.mobID());
+    }
+
+    public static SliderSignalPacket decode(FriendlyByteBuf buf) {
+        int mobID = buf.readInt();
+        return new SliderSignalPacket(mobID);
+    }
+
+
+
+    @Override
+    public Type<? extends CustomPacketPayload> type() {
+        return TYPE;
+    }
+
+
+    public static void execute(SliderSignalPacket payload, IPayloadContext context) {
+        ClientLevel level = Minecraft.getInstance().level;
+        if (level != null) {
+            Entity entity = level.getEntity(payload.mobID());
+            if (entity != null && entity.hasData(ReduxDataAttachments.SLIDER_SIGNAL.get()) && entity.getType() == AetherEntityTypes.SLIDER.get()) {
+                SliderSignalAttachment.get((Slider) entity).doBeep((Slider) entity);
+            }
+        }
+    }
+}