Fix packet count to at most 2 for the display entities at spawn

SpigotCore/SpigotCore_Main/src/de/steamwar/entity/RBlockDisplay.java

@@ -1,21 +1,22 @@
 package de.steamwar.entity;
 
-import com.comphenix.tinyprotocol.Reflection;
+import de.steamwar.Reflection;
 import de.steamwar.core.BountifulWrapper;
-import de.steamwar.core.Core;
 import lombok.Getter;
-import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.entity.EntityType;
 
+import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 
 @Getter
 public class RBlockDisplay extends RDisplay {
 
-    private BlockData block = Material.AIR.createBlockData();
+    public static final BlockData DEFAULT_BLOCK = Material.AIR.createBlockData();
+
+    private BlockData block = DEFAULT_BLOCK;
 
     public RBlockDisplay(REntityServer server, Location location) {
         super(server, EntityType.BLOCK_DISPLAY, location);
@@ -24,22 +25,19 @@ public class RBlockDisplay extends RDisplay {
     @Override
     protected void postSpawn(Consumer<Object> packetSink) {
         super.postSpawn(packetSink);
-        Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> {
+        sendPacket(packetSink, this::getBlock);
-            sendBlock(packetSink);
-        }, 0);
     }
 
     public void setBlock(BlockData block) {
         this.block = block;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getBlock);
-            sendBlock(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Class<?> iBlockDataClass = Reflection.getClass("{nms.world}.level.block.state.IBlockData");
-    private static final Reflection.MethodInvoker getState = Reflection.getTypedMethod(Reflection.getClass("{obc}.block.data.CraftBlockData"), "getState", iBlockDataClass);
+    private static final Reflection.Method getState = Reflection.getTypedMethod(Reflection.getClass("{obc}.block.data.CraftBlockData"), "getState", iBlockDataClass);
     private static final Object blockWatcher = BountifulWrapper.impl.getDataWatcherObject(22, iBlockDataClass);
-    private void sendBlock(Consumer<Object> packetSink) {
+    private void getBlock(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(blockWatcher, getState.invoke(block)));
+        if (block.getAsString(true).equals(DEFAULT_BLOCK.getAsString(true))) return;
+        packetSink.accept(blockWatcher, getState.invoke(block));
     }
 }

SpigotCore/SpigotCore_Main/src/de/steamwar/entity/RDisplay.java

@@ -13,12 +13,18 @@ import org.bukkit.util.Transformation;
 import org.joml.Quaternionf;
 import org.joml.Vector3f;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 
 @Getter
 public abstract class RDisplay extends REntity {
 
-    private Transformation transform = new Transformation(new Vector3f(), new Quaternionf(0, 0, 0, 1), new Vector3f(1, 1, 1), new Quaternionf(0, 0, 0, 1));
+    protected final Consumer<Object> updatePacketSink = o -> server.updateEntity(this, o);
+
+    public static final Transformation DEFAULT_TRANSFORM = new Transformation(new Vector3f(), new Quaternionf(0, 0, 0, 1), new Vector3f(1, 1, 1), new Quaternionf(0, 0, 0, 1));
+    private Transformation transform = DEFAULT_TRANSFORM;
 
     private int interpolationDuration = 0;
 
@@ -41,169 +47,171 @@ public abstract class RDisplay extends REntity {
     private Display.Brightness brightness = null;
 
     protected RDisplay(REntityServer server, EntityType entityType, Location location) {
-        super(server, entityType, location);
+        super(server, entityType, location, 0);
+        Bukkit.getScheduler().runTask(Core.getInstance(), () -> server.addEntity(this));
     }
 
     @Override
     protected void postSpawn(Consumer<Object> packetSink) {
         super.postSpawn(packetSink);
-        Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> {
+        sendPacket(packetSink,
-            sendTransform(packetSink);
+                this::getTransformData,
-            sendInterpolationDuration(packetSink);
+                this::getInterpolationDuration,
-            sendViewRange(packetSink);
+                this::getViewRange,
-            sendShadowRadius(packetSink);
+                this::getShadowRadius,
-            sendShadowStrength(packetSink);
+                this::getShadowStrength,
-            sendDisplayWidth(packetSink);
+                this::getDisplayWidth,
-            sendDisplayHeight(packetSink);
+                this::getDisplayHeight,
-            sendInterpolationDelay(packetSink);
+                this::getInterpolationDelay,
-            sendBillboard(packetSink);
+                this::getBillboard,
-            sendGlowColorOverride(packetSink);
+                this::getGlowColorOverride,
-            sendBrightness(packetSink);
+                this::getBrightness
-        }, 0);
+        );
+    }
+
+    @SafeVarargs
+    protected final void sendPacket(Consumer<Object> packetSink, Consumer<BiConsumer<Object, Object>>... dataSinkSinks) {
+        List<Object> keyValueData = new ArrayList<>();
+        for (Consumer<BiConsumer<Object, Object>> dataSinkSink : dataSinkSinks) {
+            dataSinkSink.accept((dataWatcher, value) -> {
+                keyValueData.add(dataWatcher);
+                keyValueData.add(value);
+            });
+        }
+        if (keyValueData.isEmpty()) return;
+        packetSink.accept(getDataWatcherPacket(keyValueData.toArray()));
     }
 
     public void setTransform(@NonNull Transformation transform) {
         this.transform = transform;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getTransformData);
-            sendTransform(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Object translationWatcher = BountifulWrapper.impl.getDataWatcherObject(10, Vector3f.class);
     private static final Object leftRotationWatcher = BountifulWrapper.impl.getDataWatcherObject(12, Quaternionf.class);
     private static final Object scaleWatcher = BountifulWrapper.impl.getDataWatcherObject(11, Vector3f.class);
     private static final Object rightRotationWatcher = BountifulWrapper.impl.getDataWatcherObject(13, Quaternionf.class);
-    private void sendTransform(Consumer<Object> packetSink) {
+    private void getTransformData(BiConsumer<Object, Object> dataSink) {
-        packetSink.accept(getDataWatcherPacket(translationWatcher, transform.getTranslation()));
+        if (transform.equals(DEFAULT_TRANSFORM)) return;
-        packetSink.accept(getDataWatcherPacket(leftRotationWatcher, transform.getLeftRotation()));
+        dataSink.accept(translationWatcher, transform.getTranslation());
-        packetSink.accept(getDataWatcherPacket(scaleWatcher, transform.getScale()));
+        dataSink.accept(leftRotationWatcher, transform.getLeftRotation());
-        packetSink.accept(getDataWatcherPacket(rightRotationWatcher, transform.getRightRotation()));
+        dataSink.accept(scaleWatcher, transform.getScale());
+        dataSink.accept(rightRotationWatcher, transform.getRightRotation());
     }
 
     public void setInterpolationDuration(int interpolationDuration) {
         this.interpolationDuration = interpolationDuration;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getInterpolationDuration);
-            sendInterpolationDuration(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Object transformationInterpolationDurationWatcher = BountifulWrapper.impl.getDataWatcherObject(8, Integer.class);
     private static final Object positionOrRotationInterpolationDurationWatcher = BountifulWrapper.impl.getDataWatcherObject(9, Integer.class);
-    private void sendInterpolationDuration(Consumer<Object> packetSink) {
+    private void getInterpolationDuration(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(transformationInterpolationDurationWatcher, interpolationDuration));
+        if (interpolationDelay == 0) return;
-        packetSink.accept(getDataWatcherPacket(positionOrRotationInterpolationDurationWatcher, interpolationDuration));
+        packetSink.accept(transformationInterpolationDurationWatcher, interpolationDuration);
+        packetSink.accept(positionOrRotationInterpolationDurationWatcher, interpolationDuration);
     }
 
     public void setViewRange(float viewRange) {
         this.viewRange = viewRange;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getViewRange);
-            sendViewRange(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Object viewRangeWatcher = BountifulWrapper.impl.getDataWatcherObject(16, Float.class);
-    private void sendViewRange(Consumer<Object> packetSink) {
+    private void getViewRange(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(viewRangeWatcher, viewRange));
+        if (viewRange == 1.0F) return;
+        packetSink.accept(viewRangeWatcher, viewRange);
     }
 
     public void setShadowRadius(float shadowRadius) {
         this.shadowRadius = shadowRadius;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getShadowRadius);
-            sendShadowRadius(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Object shadowRadiusWatcher = BountifulWrapper.impl.getDataWatcherObject(17, Float.class);
-    private void sendShadowRadius(Consumer<Object> packetSink) {
+    private void getShadowRadius(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(shadowRadiusWatcher, shadowRadius));
+        if (shadowRadius == 1.0F) return;
+        packetSink.accept(shadowRadiusWatcher, shadowRadius);
     }
 
     public void setShadowStrength(float shadowStrength) {
         this.shadowStrength = shadowStrength;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getShadowStrength);
-            sendShadowStrength(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Object shadowStrengthWatcher = BountifulWrapper.impl.getDataWatcherObject(18, Float.class);
-    private void sendShadowStrength(Consumer<Object> packetSink) {
+    private void getShadowStrength(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(shadowStrengthWatcher, shadowStrength));
+        if (shadowStrength == 1.0F) return;
+        packetSink.accept(shadowStrengthWatcher, shadowStrength);
     }
 
     public void setDisplayWidth(float displayWidth) {
         this.displayWidth = displayWidth;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getDisplayWidth);
-            sendDisplayWidth(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Object displayWidthWatcher = BountifulWrapper.impl.getDataWatcherObject(19, Float.class);
-    private void sendDisplayWidth(Consumer<Object> packetSink) {
+    private void getDisplayWidth(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(displayWidthWatcher, displayWidth));
+        if (displayWidth == 0.0F) return;
+        packetSink.accept(displayWidthWatcher, displayWidth);
     }
 
     public void setDisplayHeight(float displayHeight) {
         this.displayHeight = displayHeight;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getDisplayHeight);
-            sendDisplayHeight(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Object displayHeightWatcher = BountifulWrapper.impl.getDataWatcherObject(20, Float.class);
-    private void sendDisplayHeight(Consumer<Object> packetSink) {
+    private void getDisplayHeight(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(displayHeightWatcher, displayHeight));
+        if (displayHeight == 0.0F) return;
+        packetSink.accept(displayHeightWatcher, displayHeight);
     }
 
     public void setInterpolationDelay(int interpolationDelay) {
         this.interpolationDelay = interpolationDelay;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getInterpolationDelay);
-            sendInterpolationDelay(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Object interpolationDelayWatcher = BountifulWrapper.impl.getDataWatcherObject(7, Integer.class);
-    private void sendInterpolationDelay(Consumer<Object> packetSink) {
+    private void getInterpolationDelay(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(interpolationDelayWatcher, interpolationDelay));
+        if (interpolationDelay == 0) return;
+        packetSink.accept(interpolationDelayWatcher, interpolationDelay);
     }
 
     public void setBillboard(Display.Billboard billboard) {
         this.billboard = billboard;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getBillboard);
-            sendBillboard(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Object billboardWatcher = BountifulWrapper.impl.getDataWatcherObject(14, Byte.class);
-    private void sendBillboard(Consumer<Object> packetSink) {
+    private void getBillboard(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(billboardWatcher, (byte) billboard.ordinal()));
+        if (billboard == Display.Billboard.FIXED) return;
+        packetSink.accept(billboardWatcher, (byte) billboard.ordinal());
     }
 
     public void setGlowColorOverride(Color glowColorOverride) {
         this.glowColorOverride = glowColorOverride;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getGlowColorOverride);
-            sendGlowColorOverride(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Object glowColorOverrideWatcher = BountifulWrapper.impl.getDataWatcherObject(21, Integer.class);
-    private void sendGlowColorOverride(Consumer<Object> packetSink) {
+    private void getGlowColorOverride(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(glowColorOverrideWatcher, glowColorOverride));
+        if (glowColorOverride == null) return;
+        packetSink.accept(glowColorOverrideWatcher, glowColorOverride);
     }
 
     public void setBrightness(Display.Brightness brightness) {
         this.brightness = brightness;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getBrightness);
-            sendBrightness(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Object brightnessWatcher = BountifulWrapper.impl.getDataWatcherObject(15, Integer.class);
-    private void sendBrightness(Consumer<Object> packetSink) {
+    private void getBrightness(BiConsumer<Object, Object> packetSink) {
         if (brightness == null) {
-            packetSink.accept(getDataWatcherPacket(brightnessWatcher, -1));
+            packetSink.accept(brightnessWatcher, -1); // TODO: Potentially not needed, need to test/investigate
         } else {
             int brightnessData = brightness.getBlockLight() << 4 | brightness.getSkyLight() << 20;
-            packetSink.accept(getDataWatcherPacket(brightnessWatcher, brightnessData));
+            packetSink.accept(brightnessWatcher, brightnessData);
         }
     }
 }

SpigotCore/SpigotCore_Main/src/de/steamwar/entity/RItemDisplay.java

@@ -1,23 +1,25 @@
 package de.steamwar.entity;
 
-import com.comphenix.tinyprotocol.Reflection;
+import de.steamwar.Reflection;
 import de.steamwar.core.BountifulWrapper;
-import de.steamwar.core.Core;
 import lombok.Getter;
-import org.bukkit.Bukkit;
 import org.bukkit.Location;
+import org.bukkit.Material;
 import org.bukkit.entity.EntityType;
 import org.bukkit.entity.ItemDisplay;
 import org.bukkit.inventory.ItemStack;
 
+import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 
 @Getter
 public class RItemDisplay extends RDisplay {
 
-    private ItemStack itemStack;
+    public static final ItemStack DEFAULT_ITEM_STACK = new ItemStack(Material.AIR);
 
-    private ItemDisplay.ItemDisplayTransform itemDisplayTransform;
+    private ItemStack itemStack = DEFAULT_ITEM_STACK;
+
+    private ItemDisplay.ItemDisplayTransform itemDisplayTransform = ItemDisplay.ItemDisplayTransform.NONE;
 
     public RItemDisplay(REntityServer server, Location location) {
         super(server, EntityType.ITEM_DISPLAY, location);
@@ -26,35 +28,28 @@ public class RItemDisplay extends RDisplay {
     @Override
     protected void postSpawn(Consumer<Object> packetSink) {
         super.postSpawn(packetSink);
-        Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> {
+        sendPacket(packetSink, this::getItemStack, this::getItemDisplayTransform);
-            sendItemStack(packetSink);
-            sendItemDisplayTransform(packetSink);
-        }, 0);
     }
 
     public void setItemStack(ItemStack itemStack) {
         this.itemStack = itemStack;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getItemStack);
-            sendItemStack(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Class<?> itemStackClass = Reflection.getClass("{nms.world}.item.ItemStack");
-    private static final Reflection.MethodInvoker asNMSCopy = Reflection.getTypedMethod(Reflection.getClass("{obc}.inventory.CraftItemStack"), "asNMSCopy", itemStackClass, ItemStack.class);
+    private static final Reflection.Method asNMSCopy = Reflection.getTypedMethod(Reflection.getClass("{obc}.inventory.CraftItemStack"), "asNMSCopy", itemStackClass, ItemStack.class);
     private static final Object itemStackWatcher = BountifulWrapper.impl.getDataWatcherObject(22, itemStackClass);
-    private void sendItemStack(Consumer<Object> packetSink) {
+    private void getItemStack(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(itemStackWatcher, asNMSCopy.invoke(null, itemStack)));
+        packetSink.accept(itemStackWatcher, asNMSCopy.invoke(null, itemStack));
     }
 
     private static final Object itemDisplayTransformWatcher = BountifulWrapper.impl.getDataWatcherObject(23, Byte.class);
     public void setItemDisplayTransform(ItemDisplay.ItemDisplayTransform itemDisplayTransform) {
         this.itemDisplayTransform = itemDisplayTransform;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getItemDisplayTransform);
-            sendItemDisplayTransform(o -> server.updateEntity(this, o));
-        }
     }
 
-    private void sendItemDisplayTransform(Consumer<Object> packetSink) {
+    private void getItemDisplayTransform(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(itemDisplayTransformWatcher, (byte) itemDisplayTransform.ordinal()));
+        packetSink.accept(itemDisplayTransformWatcher, (byte) itemDisplayTransform.ordinal());
     }
 }

SpigotCore/SpigotCore_Main/src/de/steamwar/entity/RTextDisplay.java

@@ -1,15 +1,14 @@
 package de.steamwar.entity;
 
-import com.comphenix.tinyprotocol.Reflection;
+import de.steamwar.Reflection;
 import de.steamwar.core.BountifulWrapper;
 import de.steamwar.core.ChatWrapper;
-import de.steamwar.core.Core;
 import lombok.Getter;
-import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.entity.EntityType;
 import org.bukkit.entity.TextDisplay;
 
+import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 
 @Getter
@@ -36,81 +35,65 @@ public class RTextDisplay extends RDisplay {
     @Override
     protected void postSpawn(Consumer<Object> packetSink) {
         super.postSpawn(packetSink);
-        Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> {
+        sendPacket(packetSink, this::getText, this::getLineWidth, this::getTextOpacity, this::getTextStatus);
-            sendText(packetSink);
-            sendLineWidth(packetSink);
-            sendTextOpacity(packetSink);
-            sendTextStatus(packetSink);
-        }, 0);
     }
 
     public void setText(String text) {
         this.text = text;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getText);
-            sendText(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Class<?> iChatBaseComponent = Reflection.getClass("{nms.network.chat}.IChatBaseComponent");
     private static final Object textWatcher = BountifulWrapper.impl.getDataWatcherObject(22, iChatBaseComponent);
-    private void sendText(Consumer<Object> packetSink) {
+    private void getText(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(textWatcher, ChatWrapper.impl.stringToChatComponent(text)));
+        if (text.isEmpty()) return;
+        packetSink.accept(textWatcher, ChatWrapper.impl.stringToChatComponent(text));
     }
 
     public void setLineWidth(int lineWidth) {
         this.lineWidth = lineWidth;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getLineWidth);
-            sendLineWidth(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Object lineWidthWatcher = BountifulWrapper.impl.getDataWatcherObject(23, Integer.class);
-    private void sendLineWidth(Consumer<Object> packetSink) {
+    private void getLineWidth(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(lineWidthWatcher, lineWidth));
+        if (lineWidth == 200) return;
+        packetSink.accept(lineWidthWatcher, lineWidth);
     }
 
     public void setTextOpacity(byte textOpacity) {
         this.textOpacity = textOpacity;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getTextOpacity);
-            sendTextOpacity(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Object textOpacityWatcher = BountifulWrapper.impl.getDataWatcherObject(25, Byte.class);
-    private void sendTextOpacity(Consumer<Object> packetSink) {
+    private void getTextOpacity(BiConsumer<Object, Object> packetSink) {
-        packetSink.accept(getDataWatcherPacket(textOpacityWatcher, textOpacity));
+        if (textOpacity == (byte) -1) return;
+        packetSink.accept(textOpacityWatcher, textOpacity);
     }
 
     public void setShadowed(boolean shadowed) {
         this.shadowed = shadowed;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getTextStatus);
-            sendTextStatus(o -> server.updateEntity(this, o));
-        }
     }
 
     public void setSeeThrough(boolean seeThrough) {
         this.seeThrough = seeThrough;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getTextStatus);
-            sendTextStatus(o -> server.updateEntity(this, o));
-        }
     }
 
     public void setDefaultBackground(boolean defaultBackground) {
         this.defaultBackground = defaultBackground;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getTextStatus);
-            sendTextStatus(o -> server.updateEntity(this, o));
-        }
     }
 
     public void setAlignment(TextDisplay.TextAlignment alignment) {
         this.alignment = alignment;
-        if (Core.getVersion() >= 20) {
+        sendPacket(updatePacketSink, this::getTextStatus);
-            sendTextStatus(o -> server.updateEntity(this, o));
-        }
     }
 
     private static final Object textStatusWatcher = BountifulWrapper.impl.getDataWatcherObject(26, Byte.class);
-    private void sendTextStatus(Consumer<Object> packetSink) {
+    private void getTextStatus(BiConsumer<Object, Object> packetSink) {
         byte status = 0;
 
         if (shadowed) {
@@ -130,6 +113,7 @@ public class RTextDisplay extends RDisplay {
             status |= 0x0F;
         }
 
-        packetSink.accept(getDataWatcherPacket(textStatusWatcher, status));
+        if (status == 0) return;
+        packetSink.accept(textStatusWatcher, status);
     }
 }