Connaitre le contenu d'un slot, d'un inventaire player custom

[sosoh]

toi ca marche car c’est l’inventory de base, la c’est un custom, et je me demandais: avec l’inventaire de base tu dois faire event.player.inventory moi je fais directement minefusInventory, peut qu’il ne sait pas quel joueur check ? mais je ne saurais pas lui dire quel joueur check

[robin4002]

Heu ?
Attends, on reprend depuis 0.
Explique ce qui tu cherches à faire exactement et envoie toutes les classes en rapport avec.

[sosoh]

Donc, je travaille sur un mod qui rajoute un nouvel inventaire capable d’accueillir l’équipement de base mais aussi des anneaux, amulettes etc… Je souhaites que lorsque le joueur porte une nouvelle armure et l’amulette de cette armure ca donne un bonus. Donc je cherche à connaitre le contenu de mon slot à amulette, le slot 19 de mon Gui Container Custom. J’ai donc essayé avec les codes ci-dessus, mais en vain. Tu souhaites quelles classes ? Je peux t’envoyer mon dossier source si tu le souhaites.

[SCAREX]

Le problème que je vois ici c’est que (surement) ta fonction minefusInventory.getStackInSlot est statique et donc ne peut être appelée pour un joueur particulier.

EDIT : il n’est pas statique mais il est dans ta classe d’events, ce que tu dois faire c’est récupérer l’instance du minefusInventory en fonction du joueur. D’après ce que j’ai vu, tu utilises le extended properties, il te faut donc faire quelque chose comme new MinefusInventoryPlayer(player, stack[], etc.)

[robin4002]

D’accord, donc si je comprends bien tu veux ajouter des slots à l’inventaire de l’item ? Et tu as fait quoi jusqu’ici ?
Car si c’est ce que tu veux faire, il te faut un custom entity properties

[sosoh]

Non, j’ai crée un nouvel inventaire avec un keyhandler il s’ouvre, j’ai reussis, il est fonctionnel mais je n’arrive pas a “get” le contenu des nouveaux slots qui rajoutes: il reprend les slots de l’inventaire basique, et rajoute une 4eme barre en plus des slots pour les nouveaux équipements.

Les différentes class, si vous en voulez d’autre demandez moi:

​public class MinefusContainerPlayer extends Container

{
private final EntityPlayer thePlayer;

public MinefusContainerPlayer(EntityPlayer player, InventoryPlayer inventoryPlayer, MinefusInventoryPlayer inventoryMinefus)
{
this.thePlayer = player;
this.bindMinefusInventory(inventoryMinefus);
this.bindPlayerInventory(inventoryPlayer);
this.bindArmorInventory(inventoryPlayer);
}

private void bindPlayerInventory(InventoryPlayer inventoryPlayer)
{
int i;
for(i = 0; i < 9; i++)
{
this.addSlotToContainer(new Slot(inventoryPlayer, i, 8 + i * 18, 161 + 33));
}

//Barres Inventaires
        int j;
for (i = 0; i < 3; ++i)
        {
            for (j = 0; j < 9; ++j)
            {
                this.addSlotToContainer(new Slot(inventoryPlayer, j + (i + 1) * 9, 8 + j * 18, 136 + i * 18));
            }
        }
}

private void bindMinefusInventory(MinefusInventoryPlayer inventoryMinefus){

//1ere Barre Slots
this.addSlotToContainer(new Slot(inventoryMinefus, 1, 8, 119));
this.addSlotToContainer(new Slot(inventoryMinefus, 2, 26, 119));
this.addSlotToContainer(new Slot(inventoryMinefus, 3, 44, 119));
this.addSlotToContainer(new Slot(inventoryMinefus, 4, 62, 119));
this.addSlotToContainer(new Slot(inventoryMinefus, 5, 80, 119));
this.addSlotToContainer(new Slot(inventoryMinefus, 6, 98, 119));
this.addSlotToContainer(new Slot(inventoryMinefus, 7, 116, 119));
this.addSlotToContainer(new Slot(inventoryMinefus, 8, 134, 119));
this.addSlotToContainer(new Slot(inventoryMinefus, 9, 152, 119));

//Minefus Slots
this.addSlotToContainer(new SlotMinefus(inventoryMinefus, 10, 8, 8));
this.addSlotToContainer(new SlotMinefus(inventoryMinefus, 11, 8, 26));
this.addSlotToContainer(new SlotMinefus(inventoryMinefus, 12, 8, 44));
this.addSlotToContainer(new SlotMinefus(inventoryMinefus, 13, 8, 62));
this.addSlotToContainer(new SlotMinefus(inventoryMinefus, 14, 8, 80));
this.addSlotToContainer(new SlotMinefus(inventoryMinefus, 15, 8, 98));

//ArmorSlots
this.addSlotToContainer(new SlotAnneau(inventoryMinefus, 16, 28, 43));
this.addSlotToContainer(new SlotAnneau(inventoryMinefus, 17, 118, 43));
this.addSlotToContainer(new SlotBouclier(inventoryMinefus, 18, 28, 25));
this.addSlotToContainer(new SlotAmulette(inventoryMinefus, 19, 28, 7));
this.addSlotToContainer(new SlotFamilier(inventoryMinefus, 20, 118, 79));
}

private void bindArmorInventory(InventoryPlayer inventoryPlayer){
this.addSlotToContainer(new SlotArmor(thePlayer, inventoryPlayer, inventoryPlayer.getSizeInventory() - 1, 118, 7, 0));
this.addSlotToContainer(new SlotArmor(thePlayer, inventoryPlayer, inventoryPlayer.getSizeInventory() - 2, 118, 25, 1));
this.addSlotToContainer(new SlotArmor(thePlayer, inventoryPlayer, inventoryPlayer.getSizeInventory() - 3, 28, 61, 2));
this.addSlotToContainer(new SlotArmor(thePlayer, inventoryPlayer, inventoryPlayer.getSizeInventory() - 4, 28, 79, 3));
}

/**
* This should always return true, since custom inventory can be accessed from anywhere
*/
@Override
public boolean canInteractWith(EntityPlayer player)
{
return true;
}

/**
* Called when a player shift-clicks on a slot. You must override this or you will crash when someone does that.
* Basically the same as every other container I make, since I define the same constant indices for all of them
*/
@Override
public ItemStack transferStackInSlot(EntityPlayer player, int slotId)
{
ItemStack itemstack = null;
Slot slot = (Slot)this.inventorySlots.get(slotId);

if(slot != null && slot.getHasStack())
{
ItemStack itemstack1 = slot.getStack();
itemstack = itemstack1.copy();

if(slotId < 0)
{
if(!this.mergeItemStack(itemstack1, 0, this.inventorySlots.size(), true))
{
return null;
}
}
else if(!this.mergeItemStack(itemstack1, 0, 0, false))
{
return null;
}
else if(slotId == 9 && slotId != 0)
            {
if(!this.mergeItemStack(itemstack1, 0, 9, true))
                {
return null;
                }

            }
if(itemstack1.stackSize == 0)
{
slot.putStack((ItemStack)null);
}
else
{
slot.onSlotChanged();
}
}
return itemstack;
}
}

public class MinefusInventoryPlayer implements IInventory

{
/** The name your custom inventory will display in the GUI, possibly just "Inventory" */
private String name;

/** The key used to store and retrieve the inventory from NBT */
private final String tagName = "CustomInvTag";

/** Define the inventory size here for easy reference */
// This is also the place to define which slot is which if you have different types,
// for example SLOT_SHIELD = 0, SLOT_AMULET = 1;
public static final int INV_SIZE = 64;

/** Inventory's size must be same as number of slots you add to the Container class */
private ItemStack[] inventory = new ItemStack[INV_SIZE];

public MinefusInventoryPlayer()
{
}

@Override
public int getSizeInventory()
{
return inventory.length;
}

@Override
public ItemStack getStackInSlot(int slot)
{
return inventory[slot];
}

@Override
public ItemStack decrStackSize(int slot, int amount)
{
ItemStack stack = getStackInSlot(slot);
if (stack != null)
{
if (stack.stackSize > amount)
{
stack = stack.splitStack(amount);
if (stack.stackSize == 0)
{
setInventorySlotContents(slot, null);
}
}
else
{
setInventorySlotContents(slot, null);
}

this.markDirty();;
}
return stack;
}

@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
ItemStack stack = getStackInSlot(slot);
if (stack != null)
{
setInventorySlotContents(slot, null);
}
return stack;
}

@Override
public void setInventorySlotContents(int slot, ItemStack itemstack)
{
this.inventory[slot] = itemstack;

if (itemstack != null && itemstack.stackSize > this.getInventoryStackLimit())
{
itemstack.stackSize = this.getInventoryStackLimit();
}

this.markDirty();
}

@Override
public String getInventoryName()
{
return this.hasCustomInventoryName() ? this.name : "key.minefusinventory.desc";
}

public MinefusInventoryPlayer getMinefusInventory(){

return this.getMinefusInventory();
}

@Override
public boolean hasCustomInventoryName()
{
return this.name != null && this.name.length() > 0;
}

/**
* Our custom slots are similar to armor - only one item per slot
*/
@Override
public int getInventoryStackLimit()
{
return 64;
}

@Override
public void markDirty() 
{
for (int i = 0; i < this.getSizeInventory(); ++i)
{
if (this.getStackInSlot(i) != null && this.getStackInSlot(i).stackSize == 0)
this.setInventorySlotContents(i, null);
}
}

@Override
public boolean isUseableByPlayer(EntityPlayer entityplayer)
{
return true;
}

/**
* This method doesn't seem to do what it claims to do, as
* items can still be left-clicked and placed in the inventory
* even when this returns false
*/
@Override
public boolean isItemValidForSlot(int slot, ItemStack itemstack)
{
return true;
}

public void writeToNBT(NBTTagCompound compound)
{
NBTTagList items = new NBTTagList();

for (int i = 0; i < getSizeInventory(); ++i)
{
if (getStackInSlot(i) != null)
{
NBTTagCompound item = new NBTTagCompound();
item.setByte("Slot", (byte) i);
getStackInSlot(i).writeToNBT(item);
items.appendTag(item);
}
}

// We're storing our items in a custom tag list using our 'tagName' from above
// to prevent potential conflicts
compound.setTag(tagName, items);
}

public void readFromNBT(NBTTagCompound compound) {

NBTTagList items = compound.getTagList(tagName, compound.getId());
for (int i = 0; i < items.tagCount(); ++i) {

NBTTagCompound item = items.getCompoundTagAt(i);
byte slot = item.getByte("Slot");

if (slot >= 0 && slot < getSizeInventory()) {
inventory[slot] = ItemStack.loadItemStackFromNBT(item);
}
}
}

@Override
public void openInventory() {

}

@Override
public void closeInventory() {

}

public void setCustomGuiName(String name)
{
   this.name = name;
    }
}

public class SlotAmulette extends Slot

{
public SlotAmulette(IInventory inventory, int slotIndex, int x, int y)
{
super(inventory, slotIndex, x, y);
}

@Override
public boolean isItemValid(ItemStack itemstack)
{
return itemstack.getItem() == Items.apple;
}
}

public class MinefusEventHandler {

private CommonProxy proxy;
public final MinefusInventoryPlayer minefusInventory = new MinefusInventoryPlayer();

@SubscribeEvent
@SideOnly(Side.CLIENT)
public void PlayerTickEvent(TickEvent.PlayerTickEvent event)
{
if (event.player instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer) event.player;
ItemStack amulette = minefusInventory.getStackInSlot(19);
if(amulette != null && amulette.getItem() == Items.apple)
{
player.setAbsorptionAmount(1);
System.out.println("Ca marche amulette!");
}
}
}

@SubscribeEvent
@SideOnly(Side.CLIENT)
public void GuiScreenEvent(GuiOpenEvent event){
if(event.gui instanceof GuiInventory && !FMLClientHandler.instance().getClient().thePlayer.capabilities.isCreativeMode){
event.setCanceled(true);
}
}

@SubscribeEvent
public void onEntityConstructing(EntityConstructing event)
{
if (event.entity instanceof EntityPlayer && ExtendedPlayer.get((EntityPlayer) event.entity) == null)
ExtendedPlayer.register((EntityPlayer) event.entity);
if (event.entity instanceof EntityPlayer && event.entity.getExtendedProperties(ExtendedPlayer.EXT_PROP_MINEFUSINV) == null)
event.entity.registerExtendedProperties(ExtendedPlayer.EXT_PROP_MINEFUSINV, new ExtendedPlayer((EntityPlayer) event.entity));
}

@SubscribeEvent
public void onLivingDeathEvent(LivingDeathEvent event)
{
if (!event.entity.worldObj.isRemote && event.entity instanceof EntityPlayer)
{
NBTTagCompound playerData = new NBTTagCompound();
((ExtendedPlayer)(event.entity.getExtendedProperties(ExtendedPlayer.EXT_PROP_MINEFUSINV))).saveNBTData(playerData);
proxy.storeEntityData(((EntityPlayer) event.entity).getCommandSenderName() + 
ExtendedPlayer.EXT_PROP_MINEFUSINV, playerData);
ExtendedPlayer.saveProxyData((EntityPlayer) event.entity);
}
}

@SubscribeEvent
public void onEntityJoinWorld(EntityJoinWorldEvent event)
{
if (!event.entity.worldObj.isRemote && event.entity instanceof EntityPlayer)
{
NBTTagCompound playerData = proxy.getEntityData(((EntityPlayer) event.entity).getCommandSenderName());
if (playerData != null) {
((ExtendedPlayer)(event.entity.getExtendedProperties(ExtendedPlayer.EXT_PROP_MINEFUSINV))).loadNBTData(playerData);
}
((ExtendedPlayer)(event.entity.getExtendedProperties(ExtendedPlayer.EXT_PROP_MINEFUSINV))).sync();
}
}
}

[robin4002]

Bha si, tu as bien un extented entity prop par contre tu ne l’utilise pas.

Mettre ça :
public final MinefusInventoryPlayer minefusInventory = new MinefusInventoryPlayer();

En haut de la classe est MinefusEventHandler n’ai pas une bonne idée. Normalement tu devrais l’avoir dans ton ExtendedPlayer et avoir le joueur en argument pour avoir une instance par joueur.
Et il faut que tu sauvegarde le contenu de tes slots le ExtendedPlayer, sinon le contenu est perdu, ça doit être pour ça aussi qu’il considère que les slots sont vides.

[sosoh]

Mes slots sont bien save, donc je mets quel code ?
Ma classe extend:

​public class ExtendedPlayer implements IExtendedEntityProperties

{
public final static String EXT_PROP_MINEFUSINV = "ExtPropMinefusInv";

private final EntityPlayer player;
public final MinefusInventoryPlayer inventory = new MinefusInventoryPlayer();
    public ExtendedPlayer(EntityPlayer player) {
this.player = player;
}

@Override
public void saveNBTData(NBTTagCompound compound) {
NBTTagCompound properties = new NBTTagCompound();
this.inventory.writeToNBT(properties);

compound.setTag(EXT_PROP_MINEFUSINV, properties);
}

@Override
public void loadNBTData(NBTTagCompound compound) {
NBTTagCompound properties = (NBTTagCompound) compound
.getTag(EXT_PROP_MINEFUSINV);
this.inventory.readFromNBT(properties);

}

@Override
public void init(Entity entity, World world) {

}

public final void sync() {

}

public static final void register(EntityPlayer player) {
player.registerExtendedProperties(ExtendedPlayer.EXT_PROP_MINEFUSINV,
new ExtendedPlayer(player));
}

public static final ExtendedPlayer get(EntityPlayer player) {
return (ExtendedPlayer) player.getExtendedProperties(EXT_PROP_MINEFUSINV);
}

private static final String getSaveKey(EntityPlayer player) {
return player.getCommandSenderName() + ":" + EXT_PROP_MINEFUSINV;
}

public static void saveProxyData(EntityPlayer player) {
ExtendedPlayer playerData = ExtendedPlayer.get(player);
NBTTagCompound savedData = new NBTTagCompound();

playerData.saveNBTData(savedData);
CommonProxy.storeEntityData(getSaveKey(player), savedData);
}

public static final void loadProxyData(EntityPlayer player) {
ExtendedPlayer playerData = ExtendedPlayer.get(player);
NBTTagCompound savedData = CommonProxy.getEntityData(getSaveKey(player));
if (savedData != null) { playerData.loadNBTData(savedData); }
ModMinefusInventory.packetPipeline.sendTo(new SyncPlayerPropsPacket(player), (EntityPlayerMP) player);
}
}

[robin4002]

public final MinefusInventoryPlayer inventory = new MinefusInventoryPlayer();

Tu as toujours rien en rapport avec le joueur, mais bon le fait que ça ne soit plus static devrait déjà aider.

ça fonctionne toujours pas ?
Si non envoie un zip des sources, je vais regarder de mon côté.

[Superloup10]

Sinon tu peux utiliser le mod Baubles d’Azanor, il rajoute pile les slots que tu as besoin et je pense que tu devrais pouvoir faire ce que tu veux avec.

Envoyé de mon Nexus 4 en utilisant Tapatalk

[robin4002]

Bon au final le problème c’est bien que tu ne m’as pas écouté …
@‘robin4002’:

Bha si, tu as bien un extented entity prop par contre tu ne l’utilise pas.

Mettre ça :
public final MinefusInventoryPlayer minefusInventory = new MinefusInventoryPlayer();

En haut de la classe est MinefusEventHandler n’ai pas une bonne idée. Normalement tu devrais l’avoir dans ton ExtendedPlayer et avoir le joueur en argument pour avoir une instance par joueur.
Et il faut que tu sauvegarde le contenu de tes slots le ExtendedPlayer, sinon le contenu est perdu, ça doit être pour ça aussi qu’il considère que les slots sont vides.

ça veut aussi dire qu’il fallait le mettre dans la classe ExtendedPlayer ET le RETIRER de la classe MinefusEventHandler, pas le copier dans la classe ExtendedPlayer.

Donc retire-le de la classe MinefusEventHandler et mets ça à la place :

​    @SubscribeEvent

    public void PlayerTickEvent(TickEvent.PlayerTickEvent event)
    {
        ExtendedPlayer ext = ExtendedPlayer.get(event.player);
        ItemStack amulette = ext.inventory.getStackInSlot(19);
        if(amulette != null && amulette.getItem() == Items.apple)
        {
            event.player.setAbsorptionAmount(1);
            System.out.println("Ca marche amulette!");
        }
    }

Et à chaque fois que tu as besoin de l’inventaire ça sera la même chose :
ExtendedPlayer extendedPlayer = ExtendedPlayer.get(event.player);
extendedPlayer.inventory.ceQueTuVeux();

Puisqu’il faut que l’inventaire custom soit relié à la un joueur, et pas mit comme ça dans une classe.

[sosoh]

D’accord merci ! Je teste et j’edit mon post pour te dire si ça marche!

EDIT: Merci Robin ca marche! Qu’est ce que je ferais sans ton aide !