The following is my packet registry. The Client->Server packets work just fine, it's just the Server->Client ones where the context sender is null. so I'm certain I'm just missing something stupid:

 

public final class PacketRegistry
{
        /**
         * The ID for the next packet registration.
         */
        private static final String PROTOCOL_VERSION = Integer.toString(1);

        private byte nextPacketID = 0;
        /**
         * The internal network wrapper.
         */
        private static final SimpleChannel wrapper = NetworkRegistry.ChannelBuilder
                .named(new ResourceLocation(Withernauts.MODID, "main_channel"))
                .clientAcceptedVersions(PROTOCOL_VERSION::equals)
                .serverAcceptedVersions(PROTOCOL_VERSION::equals)
                .networkProtocolVersion(() -> PROTOCOL_VERSION)
                .simpleChannel();

        public void registerPackets()
        {
            //register packets going to the client
            registerServerToClient(MotionPlayerPacket.class,  MotionPlayerPacket::encode, MotionPlayerPacket::decode, MotionPlayerPacket::handle);
            registerServerToClient(PlayerLoadingPacket.class,  PlayerLoadingPacket::encode, PlayerLoadingPacket::decode, PlayerLoadingPacket::handle);
            //register packets going to the server
            registerClientToServer(CrouchSyncPacket.class, CrouchSyncPacket::encode, CrouchSyncPacket::decode, CrouchSyncPacket::handle);
            registerClientToServer(RunSyncPacket.class, RunSyncPacket::encode, RunSyncPacket::decode, RunSyncPacket::handle);
            registerClientToServer(AttackSyncPacket.class, AttackSyncPacket::encode, AttackSyncPacket::decode, AttackSyncPacket::handle);
            registerClientToServer(CombatActionPacket.class, CombatActionPacket::encode, CombatActionPacket::decode, CombatActionPacket::handle);
            registerClientToServer(ManaSyncPacket.class, ManaSyncPacket::encode, ManaSyncPacket::decode, ManaSyncPacket::handle);
            registerClientToServer(StaminaSyncPacket.class, StaminaSyncPacket::encode, StaminaSyncPacket::decode, StaminaSyncPacket::handle);
        }

        @SuppressWarnings({"unchecked", "rawtypes"})
        protected <MESSAGE> void registerServerToClient(Class<MESSAGE> type, BiConsumer<MESSAGE, PacketBuffer> encoder, Function<PacketBuffer, MESSAGE> decoder,
                                                    BiConsumer<MESSAGE, Supplier<NetworkEvent.Context>> consumer)
        {
            this.wrapper.registerMessage(nextPacketID++, type, encoder, decoder, consumer, Optional.of(NetworkDirection.PLAY_TO_CLIENT));
        }
        @SuppressWarnings({"unchecked", "rawtypes"})
        protected <MESSAGE> void registerClientToServer(Class<MESSAGE> type, BiConsumer<MESSAGE, PacketBuffer> encoder, Function<PacketBuffer, MESSAGE> decoder,
                                                    BiConsumer<MESSAGE, Supplier<NetworkEvent.Context>> consumer)
        {
            this.wrapper.registerMessage(nextPacketID++, type, encoder, decoder, consumer, Optional.of(NetworkDirection.PLAY_TO_SERVER));
        }

        /**
         * Sends the given packet to every client.
         *
         * @param message the packet to send.
         */
        public<MESSAGE> void sendToAll(MESSAGE message) {
            this.wrapper.send(PacketDistributor.ALL.noArg(), message);
        }

        /**
         * Sends the given packet to the given player.
         *
         * @param message the packet to send.
         * @param player  the player to send the packet to.
         */
        public<MESSAGE> void sendTo(MESSAGE message, ServerPlayerEntity player)
        {
            if (player.connection != null)
                this.wrapper.sendTo(message, player.connection.getNetworkManager(), NetworkDirection.PLAY_TO_CLIENT);
        }

        /**
         * Sends the given packet to all players around the given target point.
         *
         * @param message the packet to send.
         * @param point   the target point.
         */
        public<MESSAGE> void sendToAllAround(MESSAGE message, PacketDistributor.TargetPoint point)
        {
            this.wrapper.send(PacketDistributor.NEAR.with(()->point), message);
        }
        /**
         * Sends the given packet to the server.
         *
         * @param message the packet to send.
         */
        public<MESSAGE> void sendToServer(MESSAGE message)
        {
            this.wrapper.sendToServer(message);
        }

        public<MESSAGE> void sendToAllTracking(MESSAGE message, Entity entity) {
            this.wrapper.send(PacketDistributor.TRACKING_ENTITY.with(() -> entity), message);
        }
}

 

This class is called in the FMLCommonSetupEvent event hook within my main file.

 

This is a Server->Client packet that isn't working:

 

public class PlayerLoadingPacket
{
    private final int currentMana, maxMana, currentStamina, maxStamina;
    private final boolean staminaPunish;
    public PlayerLoadingPacket(int cMana, int mMana, int cStamina, int mStamina, boolean sPunish)
    {
        currentMana = cMana;
        maxMana = mMana;
        currentStamina = cStamina;
        maxStamina = mStamina;
        staminaPunish = sPunish;
    }
    public static void encode(PlayerLoadingPacket pkt, PacketBuffer buf)
    {
        buf.writeInt(pkt.currentMana);
        buf.writeInt(pkt.maxMana);
        buf.writeInt(pkt.currentStamina);
        buf.writeInt(pkt.maxStamina);
        buf.writeBoolean(pkt.staminaPunish);
    }
    public static PlayerLoadingPacket decode(PacketBuffer buf)
    {
        int cM = buf.readInt();
        int mM = buf.readInt();
        int cS = buf.readInt();
        int mS = buf.readInt();
        boolean sS = buf.readBoolean();

        return new PlayerLoadingPacket(cM, mM, cS, mS, sS);
    }
    public static void handle(PlayerLoadingPacket message, Supplier<NetworkEvent.Context> context)
    {
        NetworkEvent.Context ctx = context.get();
        ctx.enqueueWork(()->
                {
                    if (ctx.getSender()!= null)
                    {
                        EntityPlayer entityPlayer = new EntityPlayer(ctx.getSender());
                        entityPlayer.getPlayerCapability().setMana(message.currentMana);
                        entityPlayer.getPlayerCapability().setMaxMana(message.maxMana);
                        entityPlayer.getPlayerCapability().setStamina(message.currentStamina);
                        entityPlayer.getPlayerCapability().setMaxStamina(message.maxStamina);
                        entityPlayer.getPlayerCapability().setStaminaPunished(message.staminaPunish);
                        System.out.print("MANA: ");
                        System.out.print(entityPlayer.getPlayerCapability().getCurrentMana());
                        System.out.printf("%n");
                    }
                }
        );
        ctx.setPacketHandled(true);
    }
}

 

Edited January 21, 20214 yr by Turtledove

Solved it myself: when handle() is called it's (in the context of server->client) called on the logical client, ctx.getSender() is going to return null. So just use Minecraft.instance.player.