Affichage gui

[Ciolgaming]

Bonsoir,

je suis en train de me remettre aux TileEntity avec Container en 1.12.2 et j'ai juste une petite question, comment récupérer la valeur de ma variable lavaquantity dans mon gui afin d'afficher la quantité de fuel sous forme graphique

Petite image de ce que j'ai fait :

Merci de bien vouloir m'orienter dans la bonne direction, voici mon code :

Code du Gui

package fr.ciolgaming.magistry.gui;

import fr.ciolgaming.magistry.blocks.container.ContainerAcu;
import fr.ciolgaming.magistry.blocks.tileentities.TileAcu;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.util.ResourceLocation;

public class GuiAcu extends GuiContainer{
	
	private static final ResourceLocation background = new ResourceLocation("magistry","textures/gui/gui_acu.png");
	private TileAcu tile;
	
	public GuiAcu(TileAcu tile, InventoryPlayer playerInv) {
        super(new ContainerAcu(tile, playerInv));
        this.tile = tile;
        
	}
	@Override
	protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY) {
	    int i = (this.width - this.xSize) / 2;
	    int j = (this.height - this.ySize) / 2;
	    this.drawDefaultBackground();
	    this.mc.getTextureManager().bindTexture(background);
	    this.drawTexturedModalRect(i, j, 0, 0, this.xSize, this.ySize);
	 
	    int timePassed = this.tile.getField(1);
	    int textureWidth = (int) (26f / 200f * timePassed);
	    this.drawTexturedModalRect(i + 102, j + 39, 176, 14, textureWidth, 11);
	    	 
	    if (this.tile.isBurning()) {
	        int burningTime = this.tile.getField(0);
	        int textureHeight = (int) (14f / this.tile.getFullBurnTime() * burningTime);
	   //     this.drawTexturedModalRect(i + 18, j + 22, 176, 14 - textureHeight, 29, textureHeight);
	    }
	    
	    int textureH = (int) ((this.tile.getLavaLeft()*8) / 53);
	    this.drawTexturedModalRect(i + 7, j + 53, 176, 25, 18, textureH);
	    
	    this.fontRenderer.drawString("Lave : " + this.tile.getLavaLeft(), i + 3, j + 3, 0xFFFFFF);
	}
}

Code de la TileEntity :

package fr.ciolgaming.magistry.blocks.tileentities;

import fr.ciolgaming.magistry.blocks.recipes.RecipesAcu;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.init.Items;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.ItemStackHelper;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntityLockable;
import net.minecraft.util.ITickable;
import net.minecraft.util.NonNullList;
import net.minecraftforge.oredict.OreDictionary;

public class TileAcu extends TileEntityLockable implements ITickable{
	
	private NonNullList<ItemStack> stacks = NonNullList.withSize(5, ItemStack.EMPTY);
	private String customName;
	private int	timePassed = 0;
	private int	burningTimeLeft	= 0;
	private int	lavaquantity = 1;
	
	@Override
	public void readFromNBT(NBTTagCompound compound) {
	    super.readFromNBT(compound);
	    this.stacks = NonNullList.<ItemStack>withSize(this.getSizeInventory(), ItemStack.EMPTY);
	    ItemStackHelper.loadAllItems(compound, this.stacks);
	 
	    if (compound.hasKey("CustomName", 8)) {
	        this.customName = compound.getString("CustomName");
	    }
	    this.burningTimeLeft = compound.getInteger("burningTimeLeft");
	    
	    this.lavaquantity = compound.getInteger("lavaquantity");
	    
	    this.timePassed = compound.getInteger("timePassed");
	}
	 
	@Override
	public NBTTagCompound writeToNBT(NBTTagCompound compound) {
	    super.writeToNBT(compound);
	    ItemStackHelper.saveAllItems(compound, this.stacks);
	 
	    if (this.hasCustomName()) {
	        compound.setString("CustomName", this.customName);
	    }
	 
	    compound.setInteger("burningTimeLeft", this.burningTimeLeft);
	    compound.setInteger("timePassed", this.timePassed);
	    compound.setInteger("lavaquantity", this.lavaquantity);
	 
	    return compound;
	}
	
	@Override
	public boolean hasCustomName() {
	    return this.customName != null && !this.customName.isEmpty();
	}
	 
	@Override
	public String getName() {
	    return hasCustomName() ? this.customName : "tile.custom_furnace";
	}
	 
	public void setCustomName(String name) {
	    this.customName = name;
	}
	
	@Override
	public int getField(int id) {
	    switch (id) {
	        case 0:
	            return this.burningTimeLeft;
	        case 1:
	            return this.timePassed;
	    }
	    return 0;
	}
	 
	@Override
	public void setField(int id, int value) {
	    switch (id) {
	        case 0:
	            this.burningTimeLeft = value;
	            break;
	        case 1:
	            this.timePassed = value;
	    }
	}
	 
	@Override
	public int getFieldCount() {
	    return 2;
	}
	
	@Override
	public int getSizeInventory() {
	    return this.stacks.size();
	}
	 
	@Override
	public ItemStack getStackInSlot(int index) {
	    return this.stacks.get(index);
	}
	 
	@Override
	public ItemStack decrStackSize(int index, int count) {
	    return ItemStackHelper.getAndSplit(this.stacks, index, count);
	}
	 
	@Override
	public ItemStack removeStackFromSlot(int index) {
	    return ItemStackHelper.getAndRemove(stacks, index);
	}
	 
	@Override
	public void setInventorySlotContents(int index, ItemStack stack) {
	    this.stacks.set(index, stack);
	 
	    if (stack.getCount() > this.getInventoryStackLimit()) {
	        stack.setCount(this.getInventoryStackLimit());
	    }
	}
	 
	@Override
	public int getInventoryStackLimit() {
	    return 64;
	}
	 
	@Override
	public boolean isEmpty() {
	    for(ItemStack stack : this.stacks) {
	        if (!stack.isEmpty()) {
	            return false;
	        }
	    }
	    return true;
	}
	 
	@Override
	public void clear() {
	    for(int i = 0; i < this.stacks.size(); i++) {
	        this.stacks.set(i, ItemStack.EMPTY);
	    }
	}
	
	@Override
	public void openInventory(EntityPlayer player) {}
	 
	@Override
	public void closeInventory(EntityPlayer player) {}
	
	@Override
	public Container createContainer(InventoryPlayer playerInventory, EntityPlayer playerIn) {
	    return null;
	}
	 
	@Override
	public String getGuiID() {
	    return null;
	}
	
	@Override
	public boolean isItemValidForSlot(int index, ItemStack stack) {
	    // Le slot 3 je n'autorise que les planches de bois
	    if (index == 2)
	    	return stack.getItem() == Items.COAL;
	    // Le slot 4 je n'autorise que le blé
	    // Le slot 5 (celui du résultat) je n'autorise rien
	    if (index == 4)
	        return false;
	    // Sinon pour les slots 1 et 2 on met ce qu'on veut
	    return true;
	}
	
	public boolean isUsableByPlayer(EntityPlayer player) {
	    return this.world.getTileEntity(this.pos) != this ? false : player
	            .getDistanceSq((double) this.pos.getX() + 0.5D,
	                    (double) this.pos.getY() + 0.5D,
	                    (double) this.pos.getZ() + 0.5D) <= 64.0D;
	}
	
	public boolean hasFuelEmpty() {
	    return this.getStackInSlot(2).isEmpty();
	}
	
	public ItemStack getRecipeResult() {
	    return RecipesAcu.getRecipeResult(new ItemStack[] {
	            this.getStackInSlot(0), this.getStackInSlot(1) });
	}
	
	public boolean canSmelt() {
	    // On récupère le résultat de la recette
	    ItemStack result = this.getRecipeResult();
	 
	    // Le résultat est null si il n'y a pas de recette associée, donc on retourne faux
	    if (result != null && lavaquantity > 0) {
	 
	        // On récupère le contenu du slot de résultat
	        ItemStack slot4 = this.getStackInSlot(4);
	 
	        // Si il est vide on renvoie vrai
	        if (slot4.isEmpty())
	            return true;
	 
	        // Sinon on vérifie que ce soit le même objet, les même métadata et que la taille finale ne sera pas trop grande
	        if (slot4.getItem() == result.getItem() && slot4.getItemDamage() == result.getItemDamage()) {
	            int newStackSize = slot4.getCount() + result.getCount();
	            if (newStackSize <= this.getInventoryStackLimit() && newStackSize <= slot4.getMaxStackSize()) {
	                return true;
	            }
	        }
	    }
	    return false;
	}
	
	public void smelt() {
	    // Cette fonction n'est appelée que si result != null, c'est pourquoi on ne fait pas de null check
	    ItemStack result = this.getRecipeResult();
	    // On enlève un item de chaque ingrédient
	    this.decrStackSize(0, 1);
	    this.decrStackSize(1, 1);
	    lavaquantity--;
	    // On récupère le slot de résultat
	    ItemStack stack4 = this.getStackInSlot(4);
	    // Si il est vide
	    if (stack4.isEmpty()) {
	        // On y insère une copie du résultat
	        this.setInventorySlotContents(4, result.copy());
	    } else {
	        // Sinon on augmente le nombre d'objets de l'ItemStack
	        stack4.setCount(stack4.getCount() + result.getCount());
	    }
	}
	
	/** Temps de cuisson de la recette */
	public int getFullRecipeTime() {
	    return 200;
	}
	 
	/** Temps que dure 1 unité de carburant (ici : 1 planche + 1 blé) */
	public int getFullBurnTime() {
	    return 300;
	}
	
	public int getLavaLeft() {
	    return lavaquantity;
	}
	 
	/** Renvoie vrai si le feu est allumé */
	public boolean isBurning() {
		if(burningTimeLeft >0 && lavaquantity >0) {
			return true;
		}
	    return false;
	}
	
	@Override
	public void update() {
	    if (!this.world.isRemote) {
	 
	        /* Si le carburant brûle, on réduit réduit le temps restant */
	        if (this.isBurning()) {
	            this.burningTimeLeft--;
	        }
	 
	        if(!this.getStackInSlot(3).isEmpty()) {
	        	this.decrStackSize(3, 1);
	        	lavaquantity = lavaquantity+5;
	        }
	        /*
	            * Si la on peut faire cuire la recette et que le four ne cuit pas
	            * alors qu'il peut, alors on le met en route
	            */
	        if (!this.isBurning() && this.canSmelt() && !this.hasFuelEmpty()) {
	            this.burningTimeLeft = this.getFullBurnTime();
	            this.decrStackSize(2, 1);
	            
	        }
	 
	        /* Si on peut faire cuire la recette et que le feu cuit */
	        if (this.isBurning() && this.canSmelt()) {
	            this.timePassed++;
	            if (timePassed >= this.getFullRecipeTime()) {
	                timePassed = 0;
	                this.smelt();
	            }
	        } else {
	            timePassed = 0;
	        }
	        this.markDirty();
	    }
	}

}

Merci de votre réponse et vous souhaite une agréable journée,

Ciolgaming

[Daich_]

@Ciolgaming T'as essayé le

TileAcu.lavaquantity

???Moi je sais pas draw des image selon une var mais je te donne une astuce(Mets un getter si il demande de le mettre en static ou si ca te chante tu peut le mettre en static

[robin4002]

Alors sachant que la variable est privé, il faut passer par le getter.
Et comme la méthode n'est pas static, il faut passer par la variable qui contient l'instance du tile entity (ici tile).

Merci de ne pas poster de fausse réponse, surtout quand il s'agit d'erreurs concernant la base de Java.

Donc
tile.getLavaLeft()

Et pour le draw en fonction du pourcentage et toujours comme dans les autres versions, juste des math.

Tu peux la valeur courante divisée par le maximum, et tu multiplies ça par le nombre de pixels totaux de la barre.
Ensuite tu utilises ça comme valeur y pour la fonction draw.

[Ciolgaming]

Okay, déso merci de la réponse