Problème inventaire custom



  • Bonjour alors depuis j'ai recréé un inventaire ou plutôt repris un inventaire qu'on collègue m'avait fais, n'ayant plus les sources j'ai donc tout repris, seulement mon jeu crash au lancement et j'ai bon chercher je ne comprends pas pourquoi, d'après le crash report j'en conclu qu'il y a un soucis avec ma classe PacketPipeline et qu'elle serait appelé plusiseurs fois. ( peut être que je suis à côté de la plaque et que je ne cherche pas où il faut)

    Le crashreport:

    Ma classe PacketPipeline:

    package com.degraduck.minefusinventory.inventory;
    
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.EnumMap;
    import java.util.LinkedList;
    import java.util.List;
    
    import cpw.mods.fml.common.FMLCommonHandler;
    import cpw.mods.fml.common.network.FMLEmbeddedChannel;
    import cpw.mods.fml.common.network.FMLOutboundHandler;
    import cpw.mods.fml.common.network.NetworkRegistry;
    import cpw.mods.fml.common.network.internal.FMLProxyPacket;
    import cpw.mods.fml.relauncher.Side;
    import cpw.mods.fml.relauncher.SideOnly;
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    import io.netty.channel.ChannelHandler;
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.handler.codec.MessageToMessageCodec;
    import net.minecraft.client.Minecraft;
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.entity.player.EntityPlayerMP;
    import net.minecraft.network.INetHandler;
    import net.minecraft.network.NetHandlerPlayServer;
    
    public class PacketPipeline extends MessageToMessageCodec <fmlproxypacket, abstractpacket="">{
    
    private EnumMap <side, fmlembeddedchannel="">channels;
       private LinkedList<class<? extends="" abstractpacket="">> packets           = new LinkedList<class<? extends="" abstractpacket="">>();
       private boolean                                     isPostInitialised = false;
    
       /**
        * Register your packet with the pipeline. Discriminators are automatically set.
        *
        * @param clazz the class to register
        *
        * @return whether registration was successful. Failure may occur if 256 packets have been registered or if the registry already contains this packet
        */
       public boolean registerPacket(Class clazz) {
           if (this.packets.size() > 256) {
               return false;
           }
    
           if (this.packets.contains(clazz)) {
               return false;
           }
    
           if (this.isPostInitialised) {
               return false;
           }
    
           this.packets.add(clazz);
           return true;
       }
    
       @Override
       protected void encode(ChannelHandlerContext ctx, AbstractPacket msg, List <object>out) throws Exception {
           ByteBuf buffer = Unpooled.buffer();
           Class clazz = msg.getClass();
           if (!this.packets.contains(msg.getClass())) {
               throw new NullPointerException("No Packet Registered for: " + msg.getClass().getCanonicalName());
           }
    
           byte discriminator = (byte) this.packets.indexOf(clazz);
           buffer.writeByte(discriminator);
           msg.encodeInto(ctx, buffer);
           FMLProxyPacket proxyPacket = new FMLProxyPacket(buffer.copy(), ctx.channel().attr(NetworkRegistry.FML_CHANNEL).get());
           out.add(proxyPacket);
       }
    
       @Override
       protected void decode(ChannelHandlerContext ctx, FMLProxyPacket msg, List <object>out) throws Exception {
           ByteBuf payload = msg.payload();
           byte discriminator = payload.readByte();
           Class clazz = this.packets.get(discriminator);
           if (clazz == null) {
               throw new NullPointerException("No packet registered for discriminator: " + discriminator);
           }
    
           AbstractPacket pkt = clazz.newInstance();
           pkt.decodeInto(ctx, payload.slice());
    
           EntityPlayer player;
           switch (FMLCommonHandler.instance().getEffectiveSide()) {
               case CLIENT:
                   player = this.getClientPlayer();
                   pkt.handleClientSide(player);
                   break;
    
               case SERVER:
                   INetHandler netHandler = ctx.channel().attr(NetworkRegistry.NET_HANDLER).get();
                   player = ((NetHandlerPlayServer) netHandler).playerEntity;
                   pkt.handleServerSide(player);
                   break;
    
               default:
           }
    
           out.add(pkt);
       }
    
       public void initialise() {
        this.channels = NetworkRegistry.INSTANCE.newChannel("InventoryMinefus", this);
    
        registerPackets();
       }
    
       public void registerPackets() {
        registerPacket(OpenGuiPacket.class);
        registerPacket(SyncPlayerPropsPacket.class);
        }
    
       public void postInitialise() {
           if (this.isPostInitialised) {
               return;
           }
    
           this.isPostInitialised = true;
           Collections.sort(this.packets, new Comparator<class<? extends="" abstractpacket="">>() {
    
               @Override
               public int compare(Class clazz1, Class clazz2) {
                   int com = String.CASE_INSENSITIVE_ORDER.compare(clazz1.getCanonicalName(), clazz2.getCanonicalName());
                   if (com == 0) {
                       com = clazz1.getCanonicalName().compareTo(clazz2.getCanonicalName());
                   }
    
                   return com;
               }
           });
       }
    
       @SideOnly(Side.CLIENT)
       private EntityPlayer getClientPlayer() {
           return Minecraft.getMinecraft().thePlayer;
       }
    
       /**
        * Send this message to everyone.
        *
    
        * Adapted from CPW's code in cpw.mods.fml.common.network.simpleimpl.SimpleNetworkWrapper
        *
        * @param message The message to send
        */
       public void sendToAll(AbstractPacket message) {
           this.channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.ALL);
           this.channels.get(Side.SERVER).writeAndFlush(message);
       }
    
       /**
        * Send this message to the specified player.
        *
    
        * Adapted from CPW's code in cpw.mods.fml.common.network.simpleimpl.SimpleNetworkWrapper
        *
        * @param message The message to send
        * @param player  The player to send it to
        */
       public void sendTo(AbstractPacket message, EntityPlayerMP player) {
           this.channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.PLAYER);
           this.channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(player);
           this.channels.get(Side.SERVER).writeAndFlush(message);
       }
    
       /**
        * Send this message to everyone within a certain range of a point.
        *
    
        * Adapted from CPW's code in cpw.mods.fml.common.network.simpleimpl.SimpleNetworkWrapper
        *
        * @param message The message to send
        * @param point   The {@link cpw.mods.fml.common.network.NetworkRegistry.TargetPoint} around which to send
        */
       public void sendToAllAround(AbstractPacket message, NetworkRegistry.TargetPoint point) {
           this.channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.ALLAROUNDPOINT);
           this.channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(point);
           this.channels.get(Side.SERVER).writeAndFlush(message);
       }
    
       /**
        * Send this message to everyone within the supplied dimension.
        *
    
        * Adapted from CPW's code in cpw.mods.fml.common.network.simpleimpl.SimpleNetworkWrapper
        *
        * @param message     The message to send
        * @param dimensionId The dimension id to target
        */
       public void sendToDimension(AbstractPacket message, int dimensionId) {
           this.channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.DIMENSION);
           this.channels.get(Side.SERVER).attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).set(dimensionId);
           this.channels.get(Side.SERVER).writeAndFlush(message);
       }
    
       /**
        * Send this message to the server.
        *
    
        * Adapted from CPW's code in cpw.mods.fml.common.network.simpleimpl.SimpleNetworkWrapper
        *
        * @param message The message to send
        */
       public void sendToServer(AbstractPacket message) {
           this.channels.get(Side.CLIENT).attr(FMLOutboundHandler.FML_MESSAGETARGET).set(FMLOutboundHandler.OutboundTarget.TOSERVER);
           this.channels.get(Side.CLIENT).writeAndFlush(message);
       }
    }
    
    

    Ma classe principale:

    package com.degraduck.minefusinventory.common;
    
    import com.degraduck.minefusinventory.inventory.PacketPipeline;
    import com.degraduck.minefusinventory.proxy.CommonProxy;
    
    import cpw.mods.fml.common.Mod;
    import cpw.mods.fml.common.Mod.EventHandler;
    import cpw.mods.fml.common.Mod.Instance;
    import cpw.mods.fml.common.SidedProxy;
    import cpw.mods.fml.common.event.FMLInitializationEvent;
    import cpw.mods.fml.common.event.FMLPostInitializationEvent;
    import cpw.mods.fml.common.event.FMLPreInitializationEvent;
    import cpw.mods.fml.common.network.NetworkRegistry;
    
    @Mod(modid = "minefusinventory", name = "Inventaire Minefus", version = "0.1")
    
    public class MinefusInventory {
    
    private static int modGuiIndex = 0;
    public static final int GUI_MINEFUS_INV = modGuiIndex++;
    public static final PacketPipeline packetPipeline = new PacketPipeline();
    
    @Instance("minefusinventory")
    public static MinefusInventory instance;
    public static final String MODID = "minefusinventory";
    
    @SidedProxy(clientSide = "com.degraduck.minefusinventory.proxy.ClientProxy", serverSide = "com.degraduck.minefusinventory.proxy.CommonProxy")
    public static CommonProxy proxy;
    
    @EventHandler
    public void preInit(FMLPreInitializationEvent event)
    {
    
    }
    
    @EventHandler
    public void init(FMLInitializationEvent event)
    {
    
    packetPipeline.initialise();
    NetworkRegistry.INSTANCE.registerGuiHandler(this, new CommonProxy());
    
    proxy.registerRender();
    }
    
    @EventHandler
    public void postInit(FMLPostInitializationEvent event)
    {
    packetPipeline.postInitialise();
    }
    
    }
    
    Mon CommonProxy
    
    
    package com.degraduck.minefusinventory.proxy;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import com.degraduck.minefusinventory.common.MinefusInventory;
    import com.degraduck.minefusinventory.inventory.ExtendedPlayer;
    import com.degraduck.minefusinventory.inventory.GuiMinefusPlayerInventory;
    import com.degraduck.minefusinventory.inventory.MinefusContainerPlayer;
    
    import cpw.mods.fml.common.network.IGuiHandler;
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.nbt.NBTTagCompound;
    import net.minecraft.world.World;
    
    public class CommonProxy implements IGuiHandler{
    
    public void registerRender()
    {
    
    }
    
    private static final Map <string, nbttagcompound="">extendedEntityData = new HashMap<string, nbttagcompound="">();
    
    @Override
    public Object getServerGuiElement(int guiId, EntityPlayer player, World world, int x, int y, int z) {
    // TODO Auto-generated method stub
    if (guiId == MinefusInventory.GUI_MINEFUS_INV){
    return new MinefusContainerPlayer(player, player.inventory, ExtendedPlayer.get(player).inventory);}
    else{
    return null;
    }
    }
    
    @Override
    public Object getClientGuiElement(int guiId, EntityPlayer player, World world, int x, int y, int z) {
    if (guiId == MinefusInventory.GUI_MINEFUS_INV){
    return new GuiMinefusPlayerInventory(player, player.inventory, ExtendedPlayer.get(player).inventory);
    }
    
    else{
    return null;
    }
    }
    public static void storeEntityData(String name, NBTTagCompound compound)
    {
    extendedEntityData.put(name, compound);
    }
    
    /**
    * Removes the compound from the map and returns the NBT tag stored for name or null if none exists
    */
    public static NBTTagCompound getEntityData(String name)
    {
    return extendedEntityData.remove(name);
    }
    }
    
    

    je me suis aidé de ce tuto: https://github.com/coolAlias/Forge_Tutorials/blob/master/CustomPlayerInventory.java</string,></string,></class<?></object></object></class<?></class<?></side,></fmlproxypacket,></init></init></init></init></init></init>


  • Administrateurs

    Salut,
    Cette façon de faire des paquets cause des fuites de mémoire et ne doit pas être utilisé.
    Je t'invite à aller voir le tutoriel de RedRelay sur le sujet pour faire proprement tes paquets.



  • D'accord je regarde et je reviens vers vous quand j'aurai finit donner des nouvelles 🙂

    EDIT: C'est bon soucis corrigé Merci 🙂