Jump to content

[1.11] Power Capability


Awesome_Spider

Recommended Posts

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.

Relatively new to modding.

Currently developing:

https://github.com/LambdaXV/DynamicGenerators

Link to comment
Share on other sites

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;
    }
}

Link to comment
Share on other sites

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

VANILLA MINECRAFT CLASSES ARE THE BEST RESOURCES WHEN MODDING

I will be posting 1.15.2 modding tutorials on this channel. If you want to be notified of it do the normal YouTube stuff like subscribing, ect.

Forge and vanilla BlockState generator.

Link to comment
Share on other sites

Yes

Apparently I'm a complete and utter jerk and come to this forum just like to make fun of people, be confrontational, and make your personal life miserable.  If you think this is the case, JUST REPORT ME.  Otherwise you're just going to get reported when you reply to my posts and point it out, because odds are, I was trying to be nice.

 

Exception: If you do not understand Java, I WILL NOT HELP YOU and your thread will get locked.

 

DO NOT PM ME WITH PROBLEMS. No help will be given.

Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Unfortunately, your content contains terms that we do not allow. Please edit your content to remove the highlighted words below.
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Announcements



×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use.