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

[isador]

faut un system.out.println de ton itemStack amulette

[sosoh]

J’ai fait et rien ne se passe

[isador]

il te marque quoi? null?

[sosoh]

Beh non il ne marque rien… Il ne détecte pas si il y a un truc dans le slot 19 de mon inventaire…

[isador]

alors tu as un problème codé serveur je pense, il doit pas considérer tes nouveau slots comme existant

[sosoh]

C’est en solo que j’ai testé

[RedRelay]

J’ai pas ta réponse, mais je vais faire un ajout hors sujet : Si tu compte faire un effet différent pour chaque amulette, je te conseil de mettre ton code liée a l’effet dans la classe de l’amulette, sinon ça va vite être le bordel dans ton code. Tu crée un interface Amulette qui possède une methode effet() par exemple, puis lors de chaque tick (ou autre, ça depend de ce que tu veux faire), tu appel la methode effet() si l’object dans le slot de l’amulette est différent de null.

La je parle pour l’amulette, mais tu peux faire encore plus général et faire une interface pour tes items customs.

[sosoh]

En fait c’est un système de bonus: quand on porte un item d’une panoplie, ca augmente le bonus de 1, quand le bonus est 6, ça fait des effets bonus ^^ merci pour ta réponse meme si elle ne m’aide pas, actuellement ce code n’est pas dans un évent mais dans une class qui regroupe le reste de l’armure… Peut être que je dois passer par un évent ?

[SCAREX]

@‘sosoh’:

Beh non il ne marque rien… Il ne détecte pas si il y a un truc dans le slot 19 de mon inventaire…

Si ça affiche null, regarde doù vient le null, du slot, de l’item ou de l’itemStack. si ça n’affiche vraiment rien ça veut dire que ta méthode n’est pas appellée.

[sosoh]

Salut, rien ne s’affiche j’ai donc fait ca dans mon event handler mais ca ne marche toujours pas

​@SubscribeEvent

public void onLivingUpdateEvent(LivingUpdateEvent event)
{
if (event.entity instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer) event.entity;
ItemStack amulette = minefusInventory.getStackInSlot(19);
if(amulette != null && amulette.getItem() == ModDofusStuffs.StuffAmuletteBouftou)
{
player.setAbsorptionAmount(1);
System.out.println("Ca marche amulette!");
}
}
}

[SCAREX]

@‘sosoh’:

Salut, rien ne s’affiche j’ai donc fait ca dans mon event handler mais ca ne marche toujours pas

​@SubscribeEvent

public void onLivingUpdateEvent(LivingUpdateEvent event)
{
if (event.entity instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer) event.entity;
ItemStack amulette = minefusInventory.getStackInSlot(19);
if(amulette != null && amulette.getItem() == ModDofusStuffs.StuffAmuletteBouftou)
{
player.setAbsorptionAmount(1);
System.out.println("Ca marche amulette!");
}
}
}

Utilise plutôt le tick event du player et tout devrait fonctionner car actuellement tu utilise un event très général et qui ne se met à jour que dans certains cas et qui n’est pas spécifique aux joueurs.

EDIT :
Et puis, d’où vient le minefusInventory.getStackInSlot(19) ?? Que fait cette fonction, je la trouve bizarre car tu ne lui donnes pas le joueur ni de tile entity.

[sosoh]

Ca ne marche pas, je pense que ca vient de mon inventaire custom tu saurais m’aider si je t’envoie mes class ?

[SCAREX]

@‘sosoh’:

Ca ne marche pas, je pense que ca vient de mon inventaire custom tu saurais m’aider si je t’envoie mes class ?

vas-y, personnellement j’ai réussi à le faire fonctionner avec ça :

@SubscribeEvent
public void onPlayerTickEvent(PlayerTickEvent event) {
if (event.phase == Phase.START) {
ItemStack stack = event.player.inventory.getStackInSlot(19);
if (stack != null && stack.getItem() == Items.cookie) event.player.setAbsorptionAmount(1.0F);
}
}

NOTE : il faut utiliser FMLCommonHandler.instance().bus().register(new ClasseOuSeTrouveTonEvent()) pour l’enregistrer et non MinecraftForge.EVENT_BUS.register(new ClasseDeTonEvent())

[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.