[1.12.2] Render a texture above players to indicate they're typing in chat

[Major Squirrel 2]

Good evening,

I'm trying to develop a mod which renders a 2D texture above players to indicate other players that they're typing something in chat.

AFAIK I would have to override the GuiChat to handle chat opening, update and chat closing & I would have to do something about rendering (I'm inspired by the way tags work above entities, is it the right way ?).

I'm kind of confused right now because this is a client side part and I don't know how could I handle it to every player around the person typing in chat. Are packets the way to go ?

Thank you for your replies.

[Cadiboo 365]

Yeah, you would need to send a packet to the server saying that you’re typing then have the server tell other clients that info.

[Major Squirrel 2]

Good evening,

I've decided to go through an Entity for now, meaning that when a player opens a GuiChat, it sends a packet to the server and the server spawns an Entity with a custom Renderer to render the chat indicator above players head.

Here is what I did so far :

(ClientProxy.java)

public class    ClientProxy extends CommonProxy {

    @Override
    public void preInit() {
        super.preInit();

        RenderingRegistry.registerEntityRenderingHandler(EntityChatIndicator.class, RenderFactoryEntityChatIndicator.INSTANCE);
    }

    @Override
    public void init() {
        super.init();

        MinecraftForge.EVENT_BUS.register(this);
        MinecraftForge.EVENT_BUS.register(new EntityEventHandler());
    }

    @SubscribeEvent
    public void onOpenGui(GuiOpenEvent event) {
        if (event.getGui() != null) {
            if (event.getGui().getClass() == GuiChat.class) {
                event.setGui(new CustomGuiChat());
            }
        }
    }
}

 

(CustomGuiChat.java)

public class CustomGuiChat extends GuiChat {

    @Override
    public void initGui() {
        super.initGui();

        MyModMenuPacketHandler.INSTANCE.sendToServer(new ChatIndicatorMessage(1));
    }

    @Override
    public void onGuiClosed() {
        super.onGuiClosed();

        MyModMenuPacketHandler.INSTANCE.sendToServer(new ChatIndicatorMessage(0));
    }
}

 

(EntityEventHandler.java)

@Mod.EventBusSubscriber(modid = MyModMenu.MODID)
public final class EntityEventHandler {

    @SubscribeEvent
    public static void  onEntityConstructing(EntityEvent.EntityConstructing event) {
        if (event.getEntity() instanceof EntityChatIndicator) {
            System.out.println("EntityChatIndicator is being constructed !");
        }
    }

    @SubscribeEvent
    public static void  onEntityRegistering(final RegistryEvent.Register<EntityEntry> event) {
        System.out.println("Registering entities...");

        event.getRegistry().register(EntityEntryBuilder.create()
                .entity(EntityChatIndicator.class)
                .id(new ResourceLocation(MyModMenu.MODID, "chat_indicator"), 0)
                .name("chat_indicator")
                .tracker(0, 0, false)
                .build()
        );
    }
}

 

(EntityChatIndicator.java)

public class    EntityChatIndicator extends Entity {

    public  EntityChatIndicator(World worldIn) {
        this(worldIn, 0.0D, 0.0D, 0.0D);
    }

    public  EntityChatIndicator(World worldIn, double posX, double posY, double posZ) {
        super(worldIn);

        this.setSize(1.0F, 1.0F);
        this.posX = posX;
        this.posY = posY;
        this.posZ = posZ;
    }

    @Override
    protected void  entityInit() { }

    @Override
    public void onEntityUpdate() {
        super.onEntityUpdate();

        System.out.println("EntityChatIndicator position : (" + this.posX + ", " + this.posY + ", " + this.posZ + ") !");
    }

    @Override
    public void onUpdate() {
        super.onUpdate();

        System.out.println("EntityChatIndicator position : (" + this.posX + ", " + this.posY + ", " + this.posZ + ") !");
    }

    @Override
    protected void readEntityFromNBT(NBTTagCompound compound) {}

    @Override
    protected void writeEntityToNBT(NBTTagCompound compound) {}
}

 

(RenderChatIndicator.java)

@SideOnly(Side.CLIENT)
public final class  RenderChatIndicator extends Render<EntityChatIndicator> {

    public  RenderChatIndicator(RenderManager renderManager) {
        super(renderManager);
    }

    @Override
    public void doRender(EntityChatIndicator entity, double x, double y, double z, float entityYaw, float partialTicks) {
        System.out.println("Rendering EntityChatIndicator !");

        ItemStack   itemstack = new ItemStack(Items.PAPER, 1);

        if (!itemstack.isEmpty()) {
            GlStateManager.pushMatrix();
            GlStateManager.translate(x, y, z);
            GlStateManager.rotate(-this.renderManager.playerViewY, 0, 1, 0);
            GlStateManager.rotate(this.renderManager.playerViewX, 1, 0, 0);
            GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
            Minecraft.getMinecraft().getRenderItem().renderItem(itemstack, ItemCameraTransforms.TransformType.GROUND);
            GlStateManager.popMatrix();
        }

        super.doRender(entity, x, y, z, entityYaw, partialTicks);
    }

    @Nullable
    @Override
    protected ResourceLocation  getEntityTexture(EntityChatIndicator entity) {
        return (null);
    }
}

 

(RenderFactoryChatIndicator.java)

public class RenderFactoryEntityChatIndicator implements IRenderFactory<EntityChatIndicator> {

    public static final RenderFactoryEntityChatIndicator    INSTANCE = new RenderFactoryEntityChatIndicator();

    @Override
    public Render<EntityChatIndicator>  createRenderFor(RenderManager manager) {
        return (new RenderChatIndicator(manager));
    }
}

 

(MyModMenuPacketHandler.java)

public final class  MyModMenuPacketHandler {

    public static final SimpleNetworkWrapper    INSTANCE = NetworkRegistry.INSTANCE.newSimpleChannel(MyModMenu.MODID);

    private static int  discriminator = 0;

    public static <REQ extends IMessage, REPLY extends IMessage>
    void registerPacket(Class<? extends IMessageHandler<REQ, REPLY>> messageHandler, Class<REQ> message, Side side) {
        INSTANCE.registerMessage(messageHandler, message, MyModMenuPacketHandler.discriminator++, side);
    }
}

 

(ChatIndicatorMessage.java)

public final class  ChatIndicatorMessage implements IMessage {

    /**
     * First UUID key is player's UUID
     * Second Integer value is indicator's UUID
     */
    public static final Map<UUID, Integer> CHAT_INDICATORS = new HashMap<>();

    public  ChatIndicatorMessage() {}

    /**
     * 0 is to DESTROY a chat indicator
     * 1 is to CREATE a chat indicator
     */
    private int messageType;

    public  ChatIndicatorMessage(int messageType) {
        this.messageType = messageType;
    }

    @Override
    public void fromBytes(ByteBuf buf) {
        this.messageType = buf.readInt();
    }

    @Override
    public void toBytes(ByteBuf buf) {
        buf.writeInt(this.messageType);
    }

    public static final class   ChatIndicatorMessageHandler implements IMessageHandler<ChatIndicatorMessage, IMessage> {

        @Override
        public IMessage onMessage(ChatIndicatorMessage message, MessageContext ctx) {
            EntityPlayerMP  serverPlayer = ctx.getServerHandler().player;

            switch (message.messageType) {
                case 0: {
                    serverPlayer.getServerWorld().addScheduledTask(() -> {
                        Integer indicatorUniqueId = CHAT_INDICATORS.get(serverPlayer.getUniqueID());

                        if (indicatorUniqueId != null) {
                            EntityChatIndicator chatIndicator = (EntityChatIndicator) serverPlayer.world.getEntityByID(indicatorUniqueId);

                            if (chatIndicator != null) {
                                chatIndicator.setDead();
                                CHAT_INDICATORS.remove(serverPlayer.getUniqueID());
                            }
                        }
                    });

                    break;
                }
                case 1: {
                    serverPlayer.getServerWorld().addScheduledTask(() -> {
                        EntityChatIndicator chatIndicator = new EntityChatIndicator(serverPlayer.world, serverPlayer.posX, serverPlayer.posY + 0.5D, serverPlayer.posZ);

                        CHAT_INDICATORS.put(serverPlayer.getUniqueID(), chatIndicator.getEntityId());
                    });

                    break;
                }
                default:
                    break;
            }
            return null;
        }
    }
}

 

(MyModMenu.java)

@Mod(modid = MyModMenu.MODID, version = MyModMenu.VERSION)
public class    MyModMenu
{
    public static final String MODID = "mymodmenu";
    public static final String VERSION = "1.0.0";

    @Mod.Instance
    public static MyModMenu  instance;
    public static Logger            logger;

    @SidedProxy(clientSide = "net.theviolentsquirrels.proxy.ClientProxy", serverSide = "net.theviolentsquirrels.proxy.ServerProxy")
    public static CommonProxy       proxy;

    @EventHandler
    public void preInit(FMLPreInitializationEvent event) {
        MyModMenu.logger = event.getModLog();
        MyModMenu.proxy.preInit();

        MyModMenuPacketHandler.registerPacket(ChatIndicatorMessage.ChatIndicatorMessageHandler.class, ChatIndicatorMessage.class, Side.SERVER);
    }

    @EventHandler
    public void init(FMLInitializationEvent event) {
        MyModMenu.proxy.init();
    }

    @EventHandler
    public void postInit(FMLPostInitializationEvent event) {

    }
}

 

So when I'm opening a GuiChat, it correctly prints out that a packet has been sent to the server. Also, it creates a new EntityChatIndicator (caught in the EntityConstructing event). However, the doRender function and the entity updates functions do not seem to be called at all (no print at least). What I've checked is :

 

• The packet is correctly registered
• The custom renderer seems to be correctly registered with the factory way
• The entity seems to be correctly registered with the recent builder

 

I don't understand what is going on, maybe you could help me ?

EDIT: is it because my EntityChatIndicator is simply an Entity, and not an EntityLiving ? Can a simple Entity be updated ?

Edited May 7, 2019 by Major Squirrel

[Major Squirrel 2]

My bad, I've created a new instance of EntityChatIndicator but completely forgot to spawn it in the world. The following code works :

(ChatIndicatorMessage.java)

        @Override
        public IMessage onMessage(ChatIndicatorMessage message, MessageContext ctx) {
            EntityPlayerMP  serverPlayer = ctx.getServerHandler().player;

            switch (message.messageType) {
                case 0: {
                    serverPlayer.getServerWorld().addScheduledTask(() -> {
                        Integer indicatorUniqueId = CHAT_INDICATORS.get(serverPlayer.getUniqueID());

                        if (indicatorUniqueId != null) {
                            EntityChatIndicator chatIndicator = (EntityChatIndicator) serverPlayer.world.getEntityByID(indicatorUniqueId);

                            if (chatIndicator != null) {
                                chatIndicator.setDead();
                                CHAT_INDICATORS.remove(serverPlayer.getUniqueID());
                            }
                        }
                    });

                    break;
                }
                case 1: {
                    serverPlayer.getServerWorld().addScheduledTask(() -> {
                        EntityChatIndicator chatIndicator = new EntityChatIndicator(serverPlayer.world, serverPlayer.posX, serverPlayer.posY + 0.5D, serverPlayer.posZ);

                        if (serverPlayer.world.spawnEntity(chatIndicator))
                            CHAT_INDICATORS.put(serverPlayer.getUniqueID(), chatIndicator.getEntityId());
                    });

                    break;
                }
                default:
                    break;
            }
            return null;
        }

 

I also modified updateFrequency from 0 to 20 because it causes a "/ by zero" exception.

Now, entity updates functions are correctly called but still the doRender function is not called. Any guess ?

[V0idWa1k3r 391]

2 hours ago, Major Squirrel said:

public static CommonProxy proxy;

CommonProxy makes no sense. Proxies exist to separate sided-only code. If your code is common it goes anywhere else but your proxy.

 

2 hours ago, Major Squirrel said:

.tracker(0, 0, false)

Send all the clients within a 0 radius updates 0 times a second. Yeah, that's not what you want. You fixed one half of the issue, now fix the other half.

 

 

[Cadiboo 365]

You really don’t need to use an entity though

[Major Squirrel 2]

16 hours ago, V0idWa1k3r said:

Send all the clients within a 0 radius updates 0 times a second. Yeah, that's not what you want. You fixed one half of the issue, now fix the other half.

 

I've updated the tracker accordingly, thank you. ? For now, it seems that it is working as intended (see screenshot below). I've tested it in singleplayer mode and I will test it in multiplayer mode later this day.
 

Spoiler

 

8 hours ago, Cadiboo said:

You really don’t need to use an entity though

You're right, I really don't need an entity. What I don't understand with your method is what should I do - on client side - after sending packets from server to client.

[Major Squirrel 2]

Good evening,

So as @Cadiboo stated above, I've been trying to avoid using an entity to render something above players head.
 

The idea would be to send a CPacketPlayerTyping packet from the player typing to the server, then the server sends a SPacketNotifyTyping to every player around to render the indicator.

(CPacketPlayerTyping.java)

Spoiler

public class    CPacketPlayerTyping implements IMessage {

    public  CPacketPlayerTyping() {}

    @Override
    public void fromBytes(ByteBuf buf) {}

    @Override
    public void toBytes(ByteBuf buf) {}

    public static class Handler implements IMessageHandler<CPacketPlayerTyping, IMessage> {

        @Override
        public IMessage onMessage(CPacketPlayerTyping message, MessageContext ctx) {
            EntityPlayerMP  serverPlayer = ctx.getServerHandler().player;

            serverPlayer.getServerWorld().addScheduledTask(() -> {
                NetworkRegistry.TargetPoint targetPoint = new NetworkRegistry.TargetPoint(serverPlayer.dimension, serverPlayer.posX, serverPlayer.posY, serverPlayer.posZ, 20.0D);

                MyModMenuPacketHandler.INSTANCE.sendToAllAround(new SPacketNotifyTyping(serverPlayer.posX, serverPlayer.posY, serverPlayer.posZ), targetPoint);
            });

            return (null);
        }
    }
}

 

 

(SPacketNotifyTyping.java)

Spoiler

public class    SPacketNotifyTyping implements IMessage {

    private double  posX;
    private double  posY;
    private double  posZ;

    public SPacketNotifyTyping() {}

    public SPacketNotifyTyping(double posX, double posY, double posZ) {
        this.posX = posX;
        this.posY = posY;
        this.posZ = posZ;
    }

    @Override
    public void fromBytes(ByteBuf buf) {
        this.posX = buf.readDouble();
        this.posY = buf.readDouble();
        this.posZ = buf.readDouble();
    }

    @Override
    public void toBytes(ByteBuf buf) {
        buf.writeDouble(this.posX);
        buf.writeDouble(this.posY);
        buf.writeDouble(this.posZ);
    }

    public static class Handler implements IMessageHandler<SPacketNotifyTyping, IMessage> {

        @Override
        public IMessage onMessage(SPacketNotifyTyping message, MessageContext ctx) {
            EntityPlayerSP  clientPlayer = Minecraft.getMinecraft().player;

            //  What to do here ?
            return (null);
        }
    }
}

 

(CustomGuiChat.java)

Spoiler

public class    CustomGuiChat extends GuiChat {

    @Override
    public void updateScreen() {
        super.updateScreen();

        MyModMenuPacketHandler.INSTANCE.sendToServer(new CPacketPlayerTyping());
    }
}

 

 

(MyModMenu.java)

Spoiler

@EventHandler
    public void preInit(FMLPreInitializationEvent event) {
        MyModMenu.logger = event.getModLog();
        MyModMenu.proxy.preInit();

        MyModMenuPacketHandler.registerPacket(ChatIndicatorMessage.ChatIndicatorMessageHandler.class, ChatIndicatorMessage.class, Side.SERVER);
        MyModMenuPacketHandler.registerPacket(CPacketPlayerTyping.Handler.class, CPacketPlayerTyping.class, Side.SERVER);
        MyModMenuPacketHandler.registerPacket(SPacketNotifyTyping.Handler.class, SPacketNotifyTyping.class, Side.CLIENT);
    }

 

I don't know what to do next in the onMessage function of the SPacketNotifyTyping packet. I've tried to call Gl functions but it is not in an OpenGL context.

Also, I'm wondering if this is a good idea to send a packet on every screen update, what do you think ?

Edited May 9, 2019 by Major Squirrel

[Cadiboo 365]

10 minutes ago, Major Squirrel said:

Also, I'm wondering if this is a good idea to send a packet on every screen update, what do you think ?

Bad idea

 

I would do this with

player starts typing -> send packet to server

recieve packet on server -> set timeSinceLastTyping to 0 in a capability on the player

send value of capability to all clients in range

recieve value on client -> set value on clients capability

increment counter each living tick on the client if counter < 200

 

in render living/player event get the capability from the entity and if the value is < 200 render the typing image above their head.

 

 

This is maybe a little bit over engineered

[IceSun 0]

I wanna know if i need to receive a reply package , how can i do this?

I also use the 

SimpleNetworkWrapper Class

to send the network package to the server,but i need to receive some data(It means ReplyPack) from server after my request(it means RequestPack).

Edited May 12, 2019 by IceSun

[DavidM 179]

27 minutes ago, IceSun said:

I wanna know if i need to receive a reply package , how can i do this?

I also use the 

SimpleNetworkWrapper Class

to send the network package to the server,but i need to receive some data(It means ReplyPack) from server after my request(it means RequestPack).

Your problem is not related to this thread. Please create your own thread.