ItemMessage: use item metadata to create popup messages

iZanax Not really sure what you mean by "disable regular displayname popup" - if you mean stop the client showing the name of items when they're selected, then that's impossible without a client mod, sorry.

Sending a message without being queued up - that could be added, yes. The problem with that is that it's very easily abused - if everyone simply sends their message as urgent, then you'd end up with the last message sent being displayed first, and it just gets a bit silly.

 

Hey desht ! Thanks for this, it's great!

BTW I believe I've reproduced the issue Assist had with the names not returning back to normal.
For me, if I open my creative inventory while the message is being displayed, the message gets stuck on the item in my hand. Not a big deal for me since my players wont be in creative mode.

 

Thanks, I'll take a look into that.

(Does re-logging clear the stuck message? Or even moving the item around in your inventory? Since the message is purely client-side, it should be easy enough to get rid of...)

Update: confirmed, it does indeed behave weirdly in creative mode, leaving the message on the item, and it won't even clear if you re-log. I'll be looking into that...

 

Should just mention that the current version (see link in first post) simply sends the message via player.sendMessage() if the player's in creative mode, and doesn't try to do anything clever.

 

I can probably explain what's happening.

In creative mode, the server will actually receive the modified item from the client (through Packet107SetCreativeSlot), and replace it in the server-side inventory. This is because the creative inventory is entirely client-side, along with the creation of new item stacks. Quite the hack, in my view.

But it is possible to get around this. In ItemRenamer, I intercept the creative slot packet before it's processed by the server, and undo the modification by saving the original item stack in a custom NBT tag.

Notice that I use getNetworkMarker() and read the item stack manually from the original packet buffer. This is because Bukkit will remove custom NBT tags when the creative slot packet is received. But you don't have to use custom NBT tags to store your data - it's also possible to use the new attribute system for that purpose.

 

By the way, item messages seem to overwrite enchantments (temporally). If I hold an enchanted item, it looses the glow effect while the messages are received.

In addition to that I noticed that it is sometimes not working for Items I had in my hand before (and receiving a message with them), if I scroll (did it with an empty space) it does work, scrolling back on the other items, does not. But the even weirder thing is that the item begins to move down and back up very fast, just as it would if you scroll really fast. It does that in an endless loop until I open the inventory and move the bugging items.

Edit: I edited some small things, but as you can see in my pull request, nothing exotic.

 

Thanks for the PR - couple of minor tweaks needed (see my comments on github) and I'll pull it

As for the enchanted item glow - yeah, the overwritten item meta would stop that glow. Should be purely visual though - as far as the server is concerned, it's still an enchanted item. I should be able to add a glow to the faked metadata for items which already have an enchantment, though.

As for the scrolling issue, that does sound rather weird. I'll play around with that and see if I can reproduce it.

I think I have some work to do here

EDIT by Moderator: merged posts, please use the edit button instead of double posting.

 

Did the tweaks by the way

I think it's easier to reproduce if you kick the speed up a notch (I tried sending every 5 ticks)

 

desht Is it possible to disable the queue feature? If not could you add a option to disable it? I plan on using this for real time notifications and I would prefer if they weren't delayed due to the queue system. Thanks.

 

Hi ! you made an Amazing work but i found some bugs We can't break blocks when we got the PopUp, then when we Right-Click with the PopUp the DisplayName of the Item appeer That's all, Bye !

 

Right now, there's no way around the queue feature. I could implement a disable option, but consider: what happens when every other plugin decides to jump the queue too? Chaos would ensue as a bunch of messages all try to get displayed at the same time. So I'm disinclined to change the current behaviour...

 

It should just cancel all the previous tasks, so that there is just one timer running at once.

 

Can you add a function to send this without a queue ? so that you send one and it will shown if a new one will send ?

 

I noticed that it is possible (via /reload on my dev server) that

Code:java

 
private PriorityQueue<MessageRecord> getMessageQueue(Player player) {
...
}
 

returns null, causing NullPointerExceptions

 

Hello there,
Do you have something like that, that doesn't require ProtocolLib?
Thanks for your efforts!
Kind regards,
vasil7112

Hello there again.

My results without using ProtocolLib:

Code:java

package me.vasil7112.SleepyFeeling.Util;
 
import java.lang.ref.WeakReference;
import java.lang.reflect.Method;
import java.util.List;
import java.util.PriorityQueue;
 
import net.minecraft.server.v1_7_R1.PacketPlayOutSetSlot;
 
import org.apache.commons.lang.Validate;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.craftbukkit.v1_7_R1.entity.CraftPlayer;
import org.bukkit.craftbukkit.v1_7_R1.inventory.CraftItemStack;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.HandlerList;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerItemHeldEvent;
import org.bukkit.event.server.PluginDisableEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.metadata.FixedMetadataValue;
import org.bukkit.metadata.MetadataValue;
import org.bukkit.plugin.Plugin;
import org.bukkit.scheduler.BukkitRunnable;
/**
* Minecraft displays the item tooltip to the player briefly when it's changed.  Let's (ab)use that to
* send a "popup" message to the player via one of these tooltips.  This is nice for temporary messages
* where you don't want to clutter up the chat window.
*/
public class ItemMessage {
    private int interval = 20;  // ticks
    private static final int DEFAULT_DURATION = 2; // seconds
    private static final int DEFAULT_PRIORITY = 0;
    private static final String DEF_FORMAT_1 = "%s";
    private static final String DEF_FORMAT_2 = " %s ";
    private static final String METADATA_Q_KEY = "item-message:msg-queue";
    private static final String METADATA_ID_KEY = "item-message:id";
    private final Plugin plugin;
 
    private String[] formats = new String[] { DEF_FORMAT_1, DEF_FORMAT_2 };
    private Material emptyHandReplacement = Material.SNOW;
 
    public ItemMessage(Plugin plugin) {
        this.plugin = plugin;
    }
 
    /**
    * set the interval the player will receive packets with the formatted message
    * Default is 20 for every second
    * @param interval in ticks
    * @throws IllegalArgumentException if interval is below 1
    */
    public void setInterval(int interval){
        Validate.isTrue(interval > 0, "Interval can't be below 1!");
        this.interval = interval;
    }
 
    /**
    * Set which item the player should held if he receives a message
    * without having something in his hand. Default is a snow layer
    * @param material
    * @throws IllegalArgumentException if material is null
    */
    public void setEmptyHandReplacement(Material material){
        Validate.notNull(material,"There must be a replacement for an empty hand!");
        this.emptyHandReplacement = material;
    }
 
    /**
    * Send a popup message to the player, with a default duration of 2 seconds and default
    * priority level of 0.
    *
    * @param message the message to send
    * @throws IllegalStateException if the player is unavailable (e.g. went offline)
    */
    public void sendMessage(Player player, String message) {
        sendMessage(player, message, DEFAULT_DURATION, DEFAULT_PRIORITY);
    }
 
    /**
    * Send a popup message to the player, for the given duration and default priority level
    * of 0.
    *
    * @param message the message to send
    * @param duration the duration, in seconds, for which the message will be displayed
    * @throws IllegalStateException if the player is unavailable (e.g. went offline)
    */
    public void sendMessage(Player player, String message, int duration) {
        sendMessage(player, message, duration, DEFAULT_PRIORITY);
    }
 
    /**
    * Send a popup message to the player, for the given duration and priority level.
    *
    * @param message the message to send
    * @param duration the duration, in seconds, for which the message will be displayed
    * @param priority priority of this message
    * @throws IllegalStateException if the player is unavailable (e.g. went offline)
    */
    public void sendMessage(Player player, String message, int duration, int priority) {
        if (player.getGameMode() == GameMode.CREATIVE) {
            // TODO: this doesn't work properly in creative mode.  Need to investigate further
            // if it can be made to work, but for now, just send an old-fashioned chat message.
            player.sendMessage(message);
        } else {
            PriorityQueue<MessageRecord> msgQueue = getMessageQueue(player);
            msgQueue.add(new MessageRecord(message, duration, priority, getNextId(player)));
            if (msgQueue.size() == 1) {
                // there was nothing in the queue previously - kick off a NamerTask
                // (if there was already something in the queue, a new NamerTask will be kicked off
                //  when the current task completes - see notifyDone())
                new NamerTask(player, msgQueue.peek()).runTaskTimer(plugin, 1L, interval);
            }
        }
    }
 
    /**
    * Set the alternating format strings for message display.  The strings must be different
    * and must each contain one (and only one) occurrence of '%s'.
    *
    * @param formats the format strings
    * @throws IllegalArgumentException if the strings are the same, or do not contain a %s
    */
    public void setFormats(String... formats){
        Validate.isTrue(formats.length > 1, "Two formats are minimum!");
        for(String format : formats){
            Validate.isTrue(format.contains("%s"), "format string \"" + format + "\" must contain a %s");
        }
        this.formats = formats;
    }
 
    private long getNextId(Player player) {
        long id;
        if (player.hasMetadata(METADATA_ID_KEY)) {
            List<MetadataValue> l = player.getMetadata(METADATA_ID_KEY);
            id = l.size() >= 1 ? l.get(0).asLong() : 1L;
        } else {
            id = 1L;
        }
        player.setMetadata(METADATA_ID_KEY, new FixedMetadataValue(plugin, id + 1));
        return id;
    }
 
    @SuppressWarnings("unchecked")
    private PriorityQueue<MessageRecord> getMessageQueue(Player player) {
        if (!player.hasMetadata(METADATA_Q_KEY)) {
            player.setMetadata(METADATA_Q_KEY, new FixedMetadataValue(plugin, new PriorityQueue<MessageRecord>()));
        }
        for (MetadataValue v : player.getMetadata(METADATA_Q_KEY)) {
            if (v.value() instanceof PriorityQueue<?>) {
                return (PriorityQueue<MessageRecord>) v.value();
            }
        }
        return null;
    }
 
    private void notifyDone(Player player) {
        PriorityQueue<MessageRecord> msgQueue = getMessageQueue(player);
        msgQueue.poll();
        if (!msgQueue.isEmpty()) {
            MessageRecord rec = importOtherMessageRecord(msgQueue.peek());
            new NamerTask(player, rec).runTaskTimer(plugin, 1L, interval);
        }
    }
 
    /**
    * Import a foreign MessageRecord object, if possible.  Why is this necessary?  There may be multiple
    * plugins putting message records into a player's metadata, and objects from different plugins are
    * likely to be (should be!) in different packages, and will not be castable to one another.  So we
    * use reflection to convert the foreign MessageRecord's data into our local object.
    *
    * @param other the foreign message record
    * @return a MessageRecord with the imported data, or null if there was a problem
    */
    private MessageRecord importOtherMessageRecord(Object other) {
        if (other instanceof MessageRecord) {
            return (MessageRecord) other;
        } else if (other.getClass().getName().endsWith(".ItemMessage$MessageRecord")) {
            // looks like the same class as us - we make no assumptions about what package it's in, though
            try {
                Method m1 = other.getClass().getMethod("getId");
                Method m2 = other.getClass().getMethod("getPriority");
                Method m3 = other.getClass().getMethod("getMessage");
                Method m4 = other.getClass().getMethod("getDuration");
                long otherId = (Long) m1.invoke(other);
                int otherPriority = (Integer) m2.invoke(other);
                String otherMessage = (String) m3.invoke(other);
                int otherDuration = (Integer) m4.invoke(other);
                return new MessageRecord(otherMessage, otherDuration, otherPriority, otherId);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        } else {
            return null;
        }
    }
 
    private class NamerTask extends BukkitRunnable implements Listener    {
        private final WeakReference<Player> playerRef;
        private final String message;
        private int slot;
        private int iterations;
 
        public NamerTask(Player player, MessageRecord rec) {
            this.playerRef = new WeakReference<Player>(player);
            this.iterations = Math.max(1, (rec.getDuration() * 20) / interval);
            this.slot = player.getInventory().getHeldItemSlot();
            this.message = rec.getMessage();
            Bukkit.getPluginManager().registerEvents(this, plugin);
        }
 
        @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
        public void onItemHeldChange(PlayerItemHeldEvent event) {
            Player player = event.getPlayer();
            if (player.equals(playerRef.get())) {
                sendItemSlotChange(player, event.getPreviousSlot(), player.getInventory().getItem(event.getPreviousSlot()));
                slot = event.getNewSlot();
                refresh(event.getPlayer());
            }
        }
 
        @EventHandler
        public void onPluginDisable(PluginDisableEvent event) {
            Player player = playerRef.get();
            if (event.getPlugin() == plugin && player != null) {
                getMessageQueue(player).clear();
                finish(playerRef.get());
            }
        }
 
        @Override
        public void run() {
            Player player = playerRef.get();
            if (player != null) {
                if (iterations-- <= 0) {
                    // finished - restore the previous item data and tidy up
                    finish(player);
                } else {
                    // refresh the item data
                    refresh(player);
                }
            } else {
                // player probably disconnected - whatever, we're done here
                cleanup();
            }
        }
 
        private void refresh(Player player) {
            sendItemSlotChange(player, slot, makeStack(player));
        }
 
        private void finish(Player player) {
            sendItemSlotChange(player, slot, player.getInventory().getItem(slot));
            notifyDone(player);
            cleanup();
        }
 
        private void cleanup() {
            cancel();
            HandlerList.unregisterAll(this);
        }
 
        private ItemStack makeStack(Player player) {
            ItemStack stack0 = player.getInventory().getItem(slot);
            ItemStack stack;
            if (stack0 == null || stack0.getType() == Material.AIR) {
                // an empty slot can't display any custom item name, so we need to fake an item
                // a snow layer is a good choice, since it's visually quite unobtrusive
                stack = new ItemStack(emptyHandReplacement, 1);
            } else {
                stack = new ItemStack(stack0.getType(), stack0.getAmount(), stack0.getDurability());
            }
            ItemMeta meta = Bukkit.getItemFactory().getItemMeta(stack.getType());
            // fool the client into thinking the item name has changed, so it actually (re)displays it
            meta.setDisplayName(String.format(formats[iterations % formats.length], message));
            stack.setItemMeta(meta);
            return stack;
        }
 
        private void sendItemSlotChange(Player player, int slot, ItemStack stack) {
            CraftPlayer cPlayer = (CraftPlayer) player;
            PacketPlayOutSetSlot packet = new PacketPlayOutSetSlot(0,slot + 36 , CraftItemStack.asNMSCopy(stack));
            cPlayer.getHandle().playerConnection.sendPacket(packet);
        }
    }
 
    public class MessageRecord implements Comparable<Object> {
        private final String message;
        private final int duration;
        private final int priority;
        private final long id;
 
        public MessageRecord(String message, int duration, int priority, long id) {
            this.message = message;
            this.duration = duration;
            this.priority = priority;
            this.id = id;
        }
 
        public String getMessage() {
            return message;
        }
 
        public int getDuration() {
            return duration;
        }
 
        public int getPriority() {
            return priority;
        }
 
        public long getId() {
            return id;
        }
 
        @Override
        public int compareTo(Object other) {
            MessageRecord rec = importOtherMessageRecord(other);
            if (rec != null) {
                if (this.priority == rec.getPriority()) {
                    return (Long.valueOf(this.id)).compareTo(rec.getId());
                } else {
                    return (Integer.valueOf(this.priority)).compareTo(rec.getPriority());
                }
            } else {
                return 0;
            }
        }
    }
}
 

Feel free to use the above code!

EDIT by Moderator: merged posts, please use the edit button instead of double posting.

 

I see you've managed to cook up a version using direct NMS calls - that's cool, but personally I'll stick with using ProtocolLib - I like the version independence

Just realised I'd never looked at this potential problem, sorry. I'll try to remember to review that...

EDIT by Moderator: merged posts, please use the edit button instead of double posting.

 

Sure thing! Just trying to help

Goodnight and continue the nice work!

 

looks nice

 

Been playing around with this a bit. Can't seem to think of a way that I could have an itemmessage stay consistently displayed while a player is shooting snowballs? Every time a snowball fires the text updates and looks weird. I run a minigame server involving a lot of snowballs firing so this is why I care. I know I could increase the update interval but even at 1 tick it's noticable.
Thanks

 

desht, sorry if this is almost reviving an old thread, although from the looks of things the last message was only a few months ago.
I was wondering how you edited the map object to display a menu, and if it where possible to do the same to show a modified map, possibly one with regions colour coded into it. I can't seem to find anything else about how to do so with a few google searches, although I could be searching entirely the wrong thing.
I am rather new at using Bukkit, and just as new to Java. If it's a super complicated thing don't feel too obligated to explain the workings of it.

 

Me no think that.
Pseudo:
on slot change :
get slot and cache to a int "Number".
cancel event
set slot to "Number"
show message " " (Space)
I think that is possible

 

ChipDev *Pseudo

 

This is awesome! I hate the clutter sending them messages in the chat! Thanks desht