[1.11] Power Capability

[Guest]

I recently implemented CoFH's RF Api. I heard that Forge's energy capabilities are based off this api, but can it be made to take RF from other mods?

[Lambda]

I believe the mod has to support it.. Due to the fact the API is not an capability and class conventions are also different, so capability checks on a block or item would be return false for CoFH items/blocks. Usually mods just support both, but more recently people are moving away from this API. Here is an example of supporting both, if my statements above do not make sense. 

 

if (this.storage.getEnergyStored() > 0) {
                    int received = 0;
                    boolean canTakeUp = false;
                    if (slotStack.getItem() instanceof IEnergyContainerItem) { //Checking CoFH Items
                        IEnergyContainerItem item = (IEnergyContainerItem) slotStack.getItem();
                        received = (item.receiveEnergy(slotStack, this.storage.getEnergyStored(), false));
                        canTakeUp = item.getEnergyStored(slotStack) >= item.getMaxEnergyStored(slotStack);
                    } else if (slotStack.hasCapability(CapabilityEnergy.ENERGY, null)) { //Checking Forge Energy Items
                        IEnergyStorage cap = slotStack.getCapability(CapabilityEnergy.ENERGY, null);
                        if (cap != null) {
                            received = cap.receiveEnergy(this.storage.getEnergyStored(), false);
                            canTakeUp = cap.getEnergyStored() >= cap.getMaxEnergyStored();
                        }
                    }
                }

 

But honestly, just use forges energy system.

[Guest]

So I was converting code over, and it's broken. My generator is burning coal but it won't generate energy now that it is converted over to capabilities. Did I do something wrong?

 

Please excuse any messy code for the moment, I will clean it up later.

The TileEntity:

public class TileEntitySteamEngine extends TileEntity implements ITickable {

    private ItemStackHandler inventory;
    private EnergyStorage energyStorage;
    private FluidStack steamStack;
    private FluidStack waterStack;

    private float steamUsed;

    private String customName;

    private int burnTime;
    private int currentBurnTime;
    private boolean lockBurnTime;

    private int maxEnergy;
    private int energyOutput;

    public TileEntitySteamEngine() {
        inventory = new ItemStackHandler(1);
        energyStorage = new EnergyStorage(100000);

        maxEnergy = 100000;
        energyOutput = 80;

        steamUsed = 200;

        steamStack = new FluidStack(ModFluids.steam, 0);
        waterStack = new FluidStack(FluidRegistry.WATER, 0);
    }

    public IItemHandler getInventory() {
        return inventory;
    }

    public EnergyStorage getEnergyStorage() {
        return energyStorage;
    }

    public int getItemBurnTime(ItemStack stack) {
        int burnTime = 0;
        int registryFuelValue = GameRegistry.getFuelValue(stack);

        if(registryFuelValue > 0) {
            burnTime = registryFuelValue;
        } else {
           burnTime = TileEntityFurnace.getItemBurnTime(stack);
        }

        return burnTime;
    }

    public int getBurnTime() {
        return burnTime;
    }

    public int getCurrentBurnTime() {
        return currentBurnTime;
    }

    public boolean isBurning() {
        return burnTime > 0;
    }

    public boolean canItemBurn(ItemStack stack) {
        return getItemBurnTime(stack) > 0;
    }

    private void setCurrentBurnTime(int itemBurnTime) {
        currentBurnTime = itemBurnTime;
    }

    private void setBurnTime(int burnTime) {
        this.burnTime = burnTime;
    }

    public void attemptAddWater(int amount) {
        int curAmount = waterStack.amount;

        if(curAmount + amount <= 2000) {
            curAmount += amount;

            waterStack.amount = curAmount;

            markDirty();
        } else if(curAmount + amount > 2000) {
            curAmount += amount;

            curAmount -= curAmount - 2000;

            waterStack.amount = curAmount;

            markDirty();
        }
    }

    @Override
    public void update() {
        ItemStack fuelSlot = inventory.getStackInSlot(0);

        boolean dirtyFlag = false;

        if(isBurning() && !lockBurnTime){
            burnTime--;
        }

        if(!world.isRemote) {
            if (!isBurning() && !fuelSlot.isEmpty()) {
                ItemStack stack = fuelSlot;

                currentBurnTime = getItemBurnTime(stack);
                burnTime = currentBurnTime;

                stack.shrink(1);

                inventory.setStackInSlot(0, stack);

                dirtyFlag = true;
            }

            if(isBurning() || !fuelSlot.isEmpty()) {
                if(!isBurning() && canGenerate()) {
                    burnTime = getItemBurnTime(fuelSlot);
                    currentBurnTime = burnTime;

                    if (this.isBurning())
                    {
                        dirtyFlag = true;

                        if (!fuelSlot.isEmpty())
                        {
                            fuelSlot.shrink(1);

                            if (fuelSlot.isEmpty())
                            {
                                inventory.setStackInSlot(0, fuelSlot);
                            }
                        }
                    }
                }

                if (isBurning() && canGenerate())
                {
                    lockBurnTime = false;

                    generate();
                } else if(isBurning() && !canGenerate()) {
                    lockBurnTime = true;
                }
            }
        }

        if(dirtyFlag) {
            markDirty();
        }
    }

    public boolean isSteamFull() {
        return steamStack.amount == 2000;
    }

    public boolean canGenerate() {
        return energyStorage.getEnergyStored() < maxEnergy;//return storedEnergy < maxEnergy;
    }

    private void generate() {
        int steamAmt = steamStack.amount;
        int steamMax = 2000;

        int waterAmt = waterStack.amount;
        int waterMax = 2000;

        if(steamAmt == steamMax) {
            int received = energyStorage.receiveEnergy(energyOutput, true);

            if (received > 0) {
                markDirty();
            }
        }

        //If not full, make steam first
        if(steamAmt + 200 <= steamMax && waterAmt > 0) {
            waterAmt--;

            steamAmt += 200;

            waterStack.amount = waterAmt;
            steamStack.amount = steamAmt;

            markDirty();
        } else if (steamAmt + 200 > steamMax && waterAmt > 0) {
            waterAmt--;

            steamAmt += 200;
            steamAmt -= steamAmt - steamMax;

            waterStack.amount = waterAmt;
            steamStack.amount = steamAmt;

            markDirty();
        }
    }

    public int getField(int id) {
        return id == 0 ? burnTime : id == 1 ? currentBurnTime : id == 2 ? energyStorage.getEnergyStored() : id == 3 ? waterStack.amount : 0;
    }

    public void setField(int id, int value) {
        burnTime = id == 0 ? value : burnTime;
        currentBurnTime = id == 1 ? value : currentBurnTime;
        if(id == 2) {
            energyStorage.extractEnergy(energyStorage.getEnergyStored(), false);
            energyStorage.receiveEnergy(value, false);
        }
        waterStack.amount = id == 3 ? value : waterStack.amount;

        markDirty();
    }

    @Override
    public NBTTagCompound writeToNBT(NBTTagCompound compound) {
        compound.setTag("inventory", inventory.serializeNBT());
        compound.setInteger("storedEnergy", energyStorage.getEnergyStored());
        compound.setInteger("waterAmt", waterStack.amount);
        compound.setInteger("steamAmt", steamStack.amount);
        return super.writeToNBT(compound);
    }

    @Override
    public void readFromNBT(NBTTagCompound compound) {
        inventory.deserializeNBT(compound.getCompoundTag("inventory"));
      
        energyStorage = new EnergyStorage(100000);
        energyStorage.receiveEnergy(compound.getInteger("storedEnergy"), false);

        waterStack = new FluidStack(FluidRegistry.WATER, compound.getInteger("waterAmt"));
        steamStack = new FluidStack(FluidRegistry.getFluid("roboticraft_steam"), compound.getInteger("steamAmt"));
        super.readFromNBT(compound);
    }

    @Override
    public boolean hasCapability(Capability<?> capability, @Nullable EnumFacing facing) {
        return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY ||
                capability == CapabilityEnergy.ENERGY ||
                        super.hasCapability(capability, facing);
    }

    @Nullable
    @Override
    public <T> T getCapability(Capability<T> capability, @Nullable EnumFacing facing) {
        return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY ? (T)inventory :
                capability == CapabilityEnergy.ENERGY ? (T)energyStorage :
                        super.getCapability(capability, facing);
    }
}

 

The Container:

public class ContainerTileEntitySteamEngine extends Container {
    private TileEntitySteamEngine te;

    private int burnTime;
    private int currentBurnTime;
    private int storedPower;

    public ContainerTileEntitySteamEngine(IInventory playerInv, TileEntitySteamEngine te) {
        this.te = te;

        // Tile Entity, Slot 1, Slot ID 1
        this.addSlotToContainer(new SlotItemHandler(te.getInventory(), 0, 80, 40));

        // Player Inventory, Slot 9-35, Slot IDs 9-35
        for (int y = 0; y < 3; ++y) {
            for (int x = 0; x < 9; ++x) {
                this.addSlotToContainer(new Slot(playerInv, x + y * 9 + 9, 8 + x * 18, 84 + y * 18));
            }
        }

        // Player Inventory, Slot 0-8, Slot IDs 36-44
        for (int x = 0; x < 9; ++x) {
            this.addSlotToContainer(new Slot(playerInv, x, 8 + x * 18, 142));
        }
    }

    /**
     * Looks for changes made in the container, sends them to every listener.
     */
    public void detectAndSendChanges() {
        super.detectAndSendChanges();

        for(IContainerListener listener : listeners) {
            if (burnTime != te.getField(0)) {
                if (listener instanceof EntityPlayerMP) {
                    ModPacketHandler.INSTANCE.sendTo(new SteamEngineMessage(burnTime, currentBurnTime, storedPower, this.windowId), (EntityPlayerMP) listener);
                }
            }

            if (currentBurnTime != te.getField(1)) {
                if (listener instanceof EntityPlayerMP) {
                    ModPacketHandler.INSTANCE.sendTo(new SteamEngineMessage(burnTime, currentBurnTime, storedPower, this.windowId), (EntityPlayerMP) listener);
                }
            }

            if (storedPower != te.getField(2)) {
                if (listener instanceof EntityPlayerMP) {
                    ModPacketHandler.INSTANCE.sendTo(new SteamEngineMessage(burnTime, currentBurnTime, storedPower, this.windowId), (EntityPlayerMP) listener);
                }
            }
        }

        this.burnTime = this.te.getField(0);
        this.currentBurnTime = this.te.getField(1);
        this.storedPower = this.te.getField(2);
    }

    @SideOnly(Side.CLIENT)
    public void updateProgressBar(int id, int data) {
        if(id == 2) {
            te.getEnergyStorage().extractEnergy(te.getEnergyStorage().getEnergyStored(), true);
            te.getEnergyStorage().receiveEnergy(data, true);
        } else {
            this.te.setField(id, data);
        }
    }

    @Override
    public boolean canInteractWith(EntityPlayer player) {
        return true;
    }
}

 

The Packet Message:

public class SteamEngineMessage implements IMessage {
    // A default constructor is always required
    public SteamEngineMessage() {

    }

    public int burnTime;
    public int currentBurnTime;

    public int storedPower;

    public int id;

    public SteamEngineMessage(int burnTime, int currentBurnTime, int storedPower, int containerID) {
        this.burnTime = burnTime;
        this.currentBurnTime = currentBurnTime;
        this.storedPower = storedPower;
        this.id = containerID;
    }

    @Override
    public void toBytes(ByteBuf buf) {
        // Writes the int into the buf
        buf.writeInt(burnTime);
        buf.writeInt(currentBurnTime);
        buf.writeInt(storedPower);
        buf.writeInt(id);
    }

    @Override
    public void fromBytes(ByteBuf buf) {
        // Reads the int back from the buf. Note that if you have multiple values, you must read in the same order you wrote.
        burnTime = buf.readInt();
        currentBurnTime = buf.readInt();
        storedPower = buf.readInt();
        id = buf.readInt();
    }
}

 

The packet message handler:

public class SteamEngineMessageHandler implements IMessageHandler<SteamEngineMessage, IMessage> {

    @Override
    public IMessage onMessage(SteamEngineMessage message, MessageContext ctx) {
        EntityPlayer player = RobotiCraft.proxy.getPlayerFromContext(ctx);
        Container container = player.openContainer;

        if(container.windowId == message.id) {
            container.updateProgressBar(0, message.burnTime);
            container.updateProgressBar(1, message.currentBurnTime);
            container.updateProgressBar(2, message.storedPower);
        }

        return null;
    }
}

[Animefan8888]

In your generate method you call receiveEnergy and the second parameter is true when it should be false.

[Guest]

Ok. Thanks. I'll test that in the morning.

[Guest]

Even after fixing the simulate parameter it still doesn't work. Any other ideas?

[Lambda]

4 hours ago, Awesome_Spider said:

Even after fixing the simulate parameter it still doesn't work. Any other ideas?

Is the generate method being called?

[Guest]

I'm pretty sure I checked using System.out.println() statements but I'll check again.

 

Edit: Yes, generate is being called.

Edited February 11, 2017 by Awesome_Spider

[Guest]

This only happened when I removed the RF API and replaced it with capabilities. It worked perfectly before.

Edited February 11, 2017 by Awesome_Spider

[Lambda]

Is it your display not updating? Try doing this in the update function:

 

System.out.println(energyStorage.getEnergyStored());

 

And see if it increments with the energy production.

[Guest]

Oh. I never thought about that.

[Guest]

It prints 0 a bunch of times. I'll check my generating code over.

[Guest]

Oh! I feel stupid now! I think I put in code where you had to put water in before it will work! I forgot about that.

 

Edit: It's working now. *facepalm*

Edited February 12, 2017 by Awesome_Spider

[Guest]

So, if I wanted a tile entity to check around it for generators, I would use something like hasCapability right?

[Draco18s]

Yes

[Guest]

Thanks.