[1.12.2]Ma Barre d'énergie ne veux pas se mettre a jour(ou n est pas syncro)

Kporal

ok remplace energyStorage par tile et dis moi si c’est bon ?

Heaven

non faut une enumFacing

Heaven

je ne trouve toujours pas comment faire ;(

Kporal

Je ne sais vraiment pas d’où peux provenir le souci … attend un peu voir si quelqu’un d’autre peux aider

Heaven

ok bah merci quand meme

Heaven

Bonjour, comme dit dans le titre , mes capabilities ne fonctionnent pas , enfaite j ai réussi a faire une bar de rf qui augment et qui diminue selon le nombre de rf contenue mais le problème est que toute les machine sont synchronisé entre elle donc j ai inutilisé les capabilities de Minecraft mais ça ne marche toujours pas voila les deux solution que j’ai fait et qui n’ont pas marchées :

1

 @Override
    public boolean hasCapability(Capability<?> capability, EnumFacing from) {

        return capability == CapabilityEnergy.ENERGY || super.hasCapability(capability, from);
    }

    @Override
    public <T> T getCapability(Capability<T> capability, final EnumFacing from) {

        if (capability == CapabilityEnergy.ENERGY) {
            return CapabilityEnergy.ENERGY.cast(new IEnergyStorage() {

                @Override
                public int receiveEnergy(int maxReceive, boolean simulate) {

                    return TileEntityUpgradeArmorMachine.this.receiveEnergy(from, maxReceive, simulate);
                }

                @Override
                public int extractEnergy(int maxExtract, boolean simulate) {

                    return 0;
                }

                @Override
                public int getEnergyStored() {

                    return TileEntityUpgradeArmorMachine.this.getEnergyStored(from);
                }

                @Override
                public int getMaxEnergyStored() {

                    return TileEntityUpgradeArmorMachine.this.getMaxEnergyStored(from);
                }

            });
        }
        return super.getCapability(capability, from);
    }

2

@Override
    public <T> T getCapability(Capability<T> capability, final EnumFacing from) {

        if (capability == CapabilityEnergy.ENERGY)
            return (T) energyStorage;

        return super.getCapability(capability , from);
}

    @Override
    public boolean hasCapability(Capability<?> capability, EnumFacing from) {

        if (capability == CapabilityEnergy.ENERGY){
            return true;
        }
        return super.hasCapability(capability, from);
    }

j’ai mis tout ca dans ma classe TileEntity:

package com.Nugarium.NuagrMod.machine;


import cofh.redstoneflux.api.*;
import cofh.redstoneflux.impl.EnergyStorage;
import net.minecraft.util.EnumFacing;
import  net.minecraft.util.ITickable;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
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.NonNullList;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.common.capabilities.ICapabilityProvider;

import net.minecraftforge.energy.CapabilityEnergy;
import net.minecraftforge.energy.IEnergyStorage;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

public class TileEntityUpgradeArmorMachine extends TileEntityLockable implements ITickable , IEnergyInfo, IEnergyReceiver, ICapabilityProvider {
    private NonNullList<ItemStack> stacks = NonNullList.withSize(4, ItemStack.EMPTY);
    private String customName;
   // private int	timePassed = 0;
   // private int	burningTimeLeft	= 0;
    private int workingTime = 0;
    private int workingTimeNeeded = 200;

    protected static EnergyStorage energyStorage = new EnergyStorage(100000, 1000, 1000);

    @SideOnly(Side.CLIENT)
    public int getCookProgress() {
        return this.workingTime * 63 / this.workingTimeNeeded;
    }


    public EnergyStorage getEnergyStorage() {
        return energyStorage;
    }
    @Override
    public void readFromNBT(NBTTagCompound compound) {
        energyStorage.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.timePassed = compound.getInteger("timePassed");

        this.workingTime = compound.getShort("workingTime");
        this.workingTimeNeeded = compound.getShort("workingTimeNeeded");
    }
    @Override
    public NBTTagCompound writeToNBT(NBTTagCompound compound) {
        energyStorage.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.setShort("workingTime", (short)this.workingTime);
        compound.setShort("workingTimeNeeded", (short)this.workingTimeNeeded);
        return compound;
    }
    @Override
    public int getField(int id) {
        switch (id) {
            case 0:
                return this.workingTime;
            case 1:
                return this.workingTimeNeeded;
        }
        return 0;
    }
    @Override
    public void setField(int id, int value) {
        switch (id) {
            case 0:
                this.workingTime = value;
                break;
            case 1:
                this.workingTimeNeeded = 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;//new ContainerUpgradeArmorMachine(this, playerInventory);

    }



    @Override

    public String getGuiID() {

        return null;

    }

    @Override

    public boolean isItemValidForSlot(int slot, ItemStack stack) {

        return slot != 4;

    }

    @Override
    public boolean isUsableByPlayer(EntityPlayer player) {

        return this.world.getTileEntity(this.pos) != this ? false : player

                .getDistanceSq(this.pos.getX() + 0.5D,

                        this.pos.getY() + 0.5D,

                        this.pos.getZ() + 0.5D) <= 64.0D;

    }



    public ItemStack getRecipeResult() {

        return RecipesUpgradeArmorMachine.getRecipeResult(new ItemStack[] {

                this.getStackInSlot(0), this.getStackInSlot(1),  this.getStackInSlot(2) });

    }

    public boolean canSmelt() {


        ItemStack result = this.getRecipeResult();




        if (result != null) {




            ItemStack slot4 = this.getStackInSlot(3);




            if (slot4.isEmpty())

                return true;




            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 static TileEntityUpgradeArmorMachine tile;
    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);
        this.decrStackSize(2, 1);
        // On récupère le slot de résultat
        ItemStack stack4 = this.getStackInSlot(3);
        // Si il est vide
        if (stack4.isEmpty()) {
            // On y insère une copie du résultat
            this.setInventorySlotContents(3, result.copy());
        } else {
            // Sinon on augmente le nombre d'objets de l'ItemStack
            stack4.setCount(stack4.getCount() + result.getCount());
        }
    }

    public boolean isBurning() {

        return this.workingTime > 0;
    }


    @Override
    public String getName() {
        // TODO Auto-generated method stub
        return null;
    }
    @Override
    public boolean hasCustomName() {
        // TODO Auto-generated method stub
        return false;
    }


    EnumFacing e;
    @Override
    public void update() {
        if (!this.world.isRemote) {


        if (this.isBurning() && this.canSmelt() && this.getEnergyStored(e) > 0) {
            ++this.workingTime;
        }

        if (this.canSmelt() && !this.isBurning()) {
            this.workingTime = 1;
        }

        if (this.canSmelt() && this.workingTime == this.workingTimeNeeded) {
            this.smelt();
            this.workingTime = 0;
        }
        }
    }




    /*ENERGY*/

    /* IEnergyInfo */
    @Override
    public int getInfoEnergyPerTick() {

        return 0;
    }

    @Override
    public int getInfoMaxEnergyPerTick() {

        return 0;
    }

    @Override
    public int getInfoEnergyStored() {

        return energyStorage.getEnergyStored();
    }

    @Override
    public int getInfoMaxEnergyStored() {
        return 0;
    }

    /* IEnergyReceiver */
    @Override
    public int receiveEnergy(EnumFacing from, int maxReceive, boolean simulate) {

        return energyStorage.receiveEnergy(maxReceive, simulate);
    }

    @Override
    public int getEnergyStored(EnumFacing from) {

        return energyStorage.getEnergyStored();
    }

    @Override
    public int getMaxEnergyStored(EnumFacing from) {

        return energyStorage.getMaxEnergyStored();
    }

    @Override
    public boolean canConnectEnergy(EnumFacing from) {

        return energyStorage.getMaxEnergyStored() > 0;
    }


    /* CAPABILITIES */


    @Override
    public <T> T getCapability(Capability<T> capability, final EnumFacing from) {

        if (capability == CapabilityEnergy.ENERGY)
            return (T) energyStorage;

        return super.getCapability(capability , from);
}

    @Override
    public boolean hasCapability(Capability<?> capability, EnumFacing from) {

        if (capability == CapabilityEnergy.ENERGY){
            return true;
        }
        return super.hasCapability(capability, from);
    }
}

merci d’avance pour votre aide
Heaven

robin4002

Bonsoir,
Les variables static ont une seule instance par classe.
Ton problème de variable partagé vient de là, ton energyStorage n’a rien à faire en static …
Et les capabilities n’ont rien à voir dans cette histoire.

EDIT : j’ai fusionné les deux demandes comme c’est lié au même problème.

Heaven

merci a toi Robin je vais enlevé le static mais comment vais je faire pour aller chercher energystorage car sans le static ca me fait un Reported exception thrown (NPE ) ?

logs:
https://hastebin.com/ayucunalil.rb

robin4002

Le jeu crash car tu as un NPE à la ligne 68 de ElementEnergyStored.java.
Reste à trouver ce qui est null et pourquoi.

Heaven

bah enfaite c est le tile.energyrstorage… dans ElementEnergyStored qui fait un npe si EnergyStorage energystorage = new …est pas static
Edit après 1h de recherche: je ne trouve toujours pas

Heaven

ca marche toujours pas ;(

robin4002

C’est tile ou energyrstorage qui est null ? Il est censé être initialisé où ?

Heaven

c est a dire qui est censé être initialiser et ou ? car de base c est pas tile.energystorage mais storage qui est public IEnergy storage mais ca marche pas si je met ca (meme avec le code de Thermal) et c est tile qui est null si je dis pas de bêtises

robin4002

L’endroit où la variable est initialisé c’est là où il y a nomVariable = new MonObjet(...)

Heaven

oui c est public TileentiyMachine() tile;

voila mon code:

package com.Nugarium.NuagrMod.machine;


import cofh.redstoneflux.api.*;
import cofh.redstoneflux.impl.EnergyStorage;
import net.minecraft.util.ResourceLocation;

import java.util.List;



public class ElementEnergyStored extends ElementBase {

	public static final ResourceLocation DEFAULT_TEXTURE = new ResourceLocation(GuiProps.PATH_ELEMENTS + "energy.png");
	public static final int DEFAULT_SCALE = 42;

	public EnergyStorage storage;
	public TileEntityUpgradeArmorMachine tile;



	// If this is enabled, 1 pixel of energy will always show in the bar as long as it is non-zero.
	public static boolean alwaysShowMinimum = false;

	public ElementEnergyStored(GuiBase gui, int posX, int posY, EnergyStorage storage) {


		super(gui, posX, posY);

		tile = new TileEntityUpgradeArmorMachine();
		this.storage = storage;

		this.texture = DEFAULT_TEXTURE;
		this.sizeX = 16;
		this.sizeY = DEFAULT_SCALE;

		this.texW = 32;
		this.texH = 64;
	}

	public ElementEnergyStored setAlwaysShow(boolean show) {

		alwaysShowMinimum = show;
		return this;
	}

	@Override
	public void drawBackground(int mouseX, int mouseY, float gameTicks) {

		int amount = getScaled();
		RenderHelper.bindTexture(texture);
		drawTexturedModalRect(posX, posY, 0, 0, sizeX, sizeY);
		drawTexturedModalRect(posX, posY + DEFAULT_SCALE - amount, 16, DEFAULT_SCALE - amount, sizeX, amount);
	}

	@Override
	public void drawForeground(int mouseX, int mouseY) {

	}

	@Override
	public void addTooltip(List<String> list) {

		if (tile.energyStorage.getMaxEnergyStored() < 0) {
			list.add("Infinite RF");
		} else {
			list.add(StringHelper.formatNumber(tile.energyStorage.getEnergyStored()) + " / " + StringHelper.formatNumber(tile.energyStorage.getMaxEnergyStored()) + " RF");
		}
	}

	public int getScaled() {

		if (tile.energyStorage.getMaxEnergyStored() <= 0) {
			return sizeY;
		}
		long fraction = (long) tile.energyStorage.getEnergyStored() * sizeY / tile.energyStorage.getMaxEnergyStored();

		return alwaysShowMinimum && tile.energyStorage.getEnergyStored() > 0 ? Math.max(1, MathHelper.round(fraction)) : MathHelper.round(fraction);
	}

}

et si je fait ca ca ne marche pas (la texture ce load pas )

robin4002

Normal, tu génére un tile entity relié à rien.
Faut get la tile qui se trouve dans le monde via world.getTileEntity(pos).

Heaven

oui mais le problème c est que je n est pas la fontion World ni BlockPos donc comment je pourrait faire pour appeler ces deux classes ?

ca ca marcherais ?

public TileentityMachine tile;
public BlockPos pos;
public ElementEnergyStored(){

tile.getWorld().getTileEntity(pos);

}

j ai essayer et ca n a pas marcher la barre ne se draw meme pas
text alternatif

robin4002

Mais qu’est-ce que cette horreur qui n’a aucun sens ?

à quel endroit tu appeles le constructeur de ElementEnergyStored ?

Heaven

dans mon Gui dans l initGui();

@Override
    public void initGui() {

        super.initGui();
        addElement(new ElementEnergyStored(this, 150, 20, tile.getEnergyStorage()));
    }

robin4002

Voilà, donc tu as déjà le tile ici …