Jump to content

Custom chest handling not working.


Raycoms

Recommended Posts

I created my own custom chest which should imitate vanilla chest behavior but be faster for automatic mods to read its content (Don't have to read null slots for content etc).

I have a tileEntity and an Inventory.
But I have one problem

Items get lost and reappear again after emptying some items or after reopening a bunch of times. When debugging it seems like the same tileEntity has two different versions of the inventory.
 

package com.minecolonies.coremod.tileentities;

import com.minecolonies.coremod.inventory.InventoryChest;
import com.minecolonies.coremod.lib.Constants;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntityChest;

import javax.annotation.Nullable;

public class TileEntityMinecoloniesChest extends TileEntityChest
{
    /**
     * Tag to store inventory to nbt.
     */
    private static final String TAG_INVENTORY  = "inventory";

    /**
     * The inventory connected with the scarecrow.
     */
    private InventoryChest chest;

    public TileEntityMinecoloniesChest()
    {
        super();
        chest = new InventoryChest();
    }

    /**
     * Returns the stack in the given slot.
     */
    @Nullable
    @Override
    public ItemStack getStackInSlot(int index)
    {
        return chest.getStackInSlot(index);
    }

    @Override
    public void readFromNBT(final NBTTagCompound compound)
    {
        super.readFromNBT(compound);
        chest = InventoryChest.deserializeFromNBT(compound.getCompoundTag(Constants.MOD_ID + TAG_INVENTORY));
    }

    @Override
    public NBTTagCompound writeToNBT(final NBTTagCompound compound)
    {
        final NBTTagCompound localCompound = super.writeToNBT(compound);
        if(chest != null)
        {
            localCompound.setTag(Constants.MOD_ID + TAG_INVENTORY, chest.serializeNBT());
        }
        return localCompound;
    }

    public void close()
    {
        numPlayersUsing = 0;
    }

    /**
     * Removes up to a specified number of items from an inventory slot and returns them in a new stack.
     */
    @Nullable
    @Override
    public ItemStack decrStackSize(int index, int count)
    {
        return chest.decrStackSize(index, count);
    }

    /**
     * Removes a stack from the given slot and returns it.
     */
    @Nullable
    @Override
    public ItemStack removeStackFromSlot(int index)
    {
        return chest.removeStackFromSlot(index);
    }

    /**
     * Sets the given item stack to the specified slot in the inventory (can be crafting or armor sections).
     */
    @Override
    public void setInventorySlotContents(int index, @Nullable ItemStack stack)
    {
        chest.setInventorySlotContents(index, stack);
    }

    /**
     * Clear the inventory.
     */
    @Override
    public void clear()
    {
        chest.clear();
    }

    /**
     * Getter for the inventory.
     * @return the stackHandler.
     */
    public InventoryChest getInventory()
    {
        return this.chest;
    }

    /**
     * Set the inventory.
     * @param inventory to set.
     */
    public void setInventory(final InventoryChest inventory)
    {
        this.chest = inventory;
    }
}

 

package com.minecolonies.coremod.inventory;

import com.minecolonies.coremod.tileentities.TileEntityMinecoloniesChest;
import com.minecolonies.coremod.util.ExtendedItemStack;
import com.minecolonies.coremod.util.InventoryUtils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.Constants;
import net.minecraftforge.items.IItemHandler;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.HashMap;

/**
 * The custom chest of the field.
 */
public class InventoryChest extends Container implements IItemHandler
{
    /**
     * The size of a normal inventory.
     */
    private static final int MAX_INVENTORY_INDEX = 27;

    /**
     * The size of the the inventory hotbar.
     */
    private static final int INVENTORY_HOT_BAR_SIZE = 9;

    /**
     * Tag to store the content.
     */
    private static final String TAG_CONTENT = "items";

    /**
     * TileEntity of the chest.
     */
    private final TileEntityMinecoloniesChest entity;

    /**
     * The hashmap with the content of the inventory.
     */
    private final HashMap<ExtendedItemStack, ExtendedItemStack> content = new HashMap<>();

    public InventoryChest(@NotNull final TileEntityMinecoloniesChest tileEntity,
            final InventoryPlayer playerInventory)
    {
        super();

        tileEntity.openInventory(playerInventory.player);
        int i = (3 - 4) * 18;

        for (int j = 0; j < 3; ++j)
        {
            for (int k = 0; k < 9; ++k)
            {
                this.addSlotToContainer(new Slot(tileEntity, k + j * 9, 8 + k * 18, 18 + j * 18));
            }
        }

        for (int l = 0; l < 3; ++l)
        {
            for (int j1 = 0; j1 < 9; ++j1)
            {
                this.addSlotToContainer(new Slot(playerInventory, j1 + l * 9 + 9, 8 + j1 * 18, 103 + l * 18 + i));
            }
        }

        for (int i1 = 0; i1 < 9; ++i1)
        {
            this.addSlotToContainer(new Slot(playerInventory, i1, 8 + i1 * 18, 161 + i));
        }

        this.content.putAll(tileEntity.getInventory().content);
        tileEntity.setInventory(this);
        this.entity = tileEntity;
    }

    public InventoryChest()
    {
        super();
        this.entity = null;
    }

    @Override
    public int getSlots()
    {
        return MAX_INVENTORY_INDEX;
    }
    @Override
    public void onContainerClosed(final EntityPlayer playerIn)
    {
        entity.close();
    }

    @Override
    public ItemStack insertItem(final int slot, final ItemStack stack, final boolean simulate)
    {
        return null;
    }

    @Override
    public ItemStack extractItem(final int slot, final int amount, final boolean simulate)
    {
        return null;
    }

    /**
     * Mark the tileEntity of this inventory dirty.
     */
    private void markDirty()
    {
        if(this.entity != null)
        {
            entity.setInventory(this);
            entity.markDirty();
        }
    }

    /**
     * Returns the stack in the given slot.
     */
    @Nullable
    @Override
    public ItemStack getStackInSlot(int index)
    {
        int i = 0;
        for (final ExtendedItemStack stack : content.values())
        {
            int totalAmount = stack.getAmount();
            double divisor = Math.max(64, totalAmount) / 64.0;

            for (int partialStacks = 0; partialStacks < divisor; partialStacks++)
            {
                int size = Math.min(64, totalAmount);

                if (i + partialStacks == index)
                {
                    final ItemStack returnStack = stack.getStack().copy();
                    returnStack.stackSize = size;
                    return returnStack;
                }
                totalAmount -= size;
            }
            i += divisor;
        }
        return InventoryUtils.EMPTY;
    }

    public static InventoryChest deserializeFromNBT(final NBTTagCompound compound)
    {
        final InventoryChest chest = new InventoryChest();
        final NBTTagList nbttaglist = compound.getTagList(TAG_CONTENT, Constants.NBT.TAG_COMPOUND);
        for (int i = 0; i < nbttaglist.tagCount(); ++i)
        {
            final NBTTagCompound nbttagcompound = nbttaglist.getCompoundTagAt(i);
            final ExtendedItemStack stack = ExtendedItemStack.readFromNBT(nbttagcompound);
            chest.content.put(stack, stack);
        }
        return chest;
    }

    @Nullable
    @Override
    public ItemStack transferStackInSlot(@NotNull final EntityPlayer playerIn, final int slotIndex)
    {
        if (slotIndex < this.getSlots())
        {
            playerIn.inventory.addItemStackToInventory(this.getStackInSlot(slotIndex));
            this.removeStackFromSlot(slotIndex);
        }
        else
        {
            int index = slotIndex - this.getSlots();
            index = index >= MAX_INVENTORY_INDEX ? index - MAX_INVENTORY_INDEX
                    : index + INVENTORY_HOT_BAR_SIZE;
            if (playerIn.inventory.getStackInSlot(index) != InventoryUtils.EMPTY)
            {
                int remain = this.addToInventory(playerIn.inventory.getStackInSlot(index));
                playerIn.inventory.getStackInSlot(index).splitStack(64 - remain);
                if (playerIn.inventory.getStackInSlot(index).stackSize == 0)
                {
                    playerIn.inventory.removeStackFromSlot(index);
                }
            }
        }

        markDirty();
        return InventoryUtils.EMPTY;
    }

    private int addToInventory(final ItemStack stackInSlot)
    {
        markDirty();
        int fullSlots = 0;

        for(ExtendedItemStack stack: content.values())
        {
            fullSlots += Math.ceil(stack.getAmount() / 64.0);
        }

        if(fullSlots >= getSlots())
        {
            //todo check if can fill up a stack.
            return stackInSlot.stackSize;
        }

        final int stackSize = stackInSlot.stackSize;
        stackInSlot.stackSize = 0;
        if (content.containsKey(new ExtendedItemStack(stackInSlot, 0)))
        {
            ExtendedItemStack ext = content.remove(new ExtendedItemStack(stackInSlot, 0));
            ext.increaseAmount(stackSize);
            content.put(ext, ext);
        }
        else
        {
            final ExtendedItemStack ext = new ExtendedItemStack(stackInSlot, stackSize);
            content.put(ext, ext);
        }

        return 0;
    }

    public NBTTagCompound serializeNBT()
    {
        final NBTTagCompound compound = new NBTTagCompound();
        final NBTTagList nbttaglist = new NBTTagList();
        for (final ExtendedItemStack stack : content.values())
        {
            final NBTTagCompound stackCompound = new NBTTagCompound();
            stack.writeToNBT(stackCompound);
            nbttaglist.appendTag(stackCompound);
        }
        compound.setTag(TAG_CONTENT, nbttaglist);
        return compound;
    }

    /**
     * Removes up to a specified number of items from an inventory slot and returns them in a new stack.
     */
    @Nullable
    public ItemStack decrStackSize(int index, int count)
    {
        markDirty();
        int i = 0;
        for (final ExtendedItemStack stack : content.values())
        {
            int totalAmount = stack.getAmount();
            double divisor = Math.max(64, totalAmount) / 64.0;

            for (int partialStacks = 0; partialStacks < divisor; partialStacks++)
            {
                int size = Math.min(64, totalAmount);
                if (i + partialStacks == index)
                {
                    final ItemStack returnStack = stack.getAsItemStackWithAmount(count);
                    if (stack.getAmount() == 0)
                    {
                        content.remove(stack);
                    }
                    return returnStack;
                }
                totalAmount -= size;
            }
            i += divisor;
        }
        return InventoryUtils.EMPTY;
    }

    /**
     * Removes a stack from the given slot and returns it.
     */
    @Nullable
    public ItemStack removeStackFromSlot(int index)
    {
        markDirty();
        int i = 0;
        for (final ExtendedItemStack stack : content.values())
        {
            int totalAmount = stack.getAmount();
            double divisor = Math.max(64, totalAmount) / 64.0;

            for (int partialStacks = 0; partialStacks < divisor; partialStacks++)
            {
                int size = Math.min(64, totalAmount);

                if (i + partialStacks == index)
                {
                    final ItemStack returnStack = stack.getAsItemStackWithAmount(size);
                    if(stack.getAmount() <= 0)
                    {
                        content.remove(stack);
                    }
                    return returnStack;
                }
                totalAmount -= size;
            }
            i += divisor;
        }
        return InventoryUtils.EMPTY;
    }

    /**
     * Sets the given item stack to the specified slot in the inventory (can be crafting or armor sections).
     * @param index the index.
     * @param stack the incoming stack.
     */
    public void setInventorySlotContents(int index, @Nullable ItemStack stack)
    {
        markDirty();
        if (stack == null)
        {
            return;
        }

        int i = 0;
        for (final ExtendedItemStack exStack : new HashMap<>(content).values())
        {
            int totalAmount = exStack.getAmount();
            double divisor = Math.max(64, totalAmount) / 64.0;

            for (int partialStacks = 0; partialStacks < divisor; partialStacks++)
            {
                int size = Math.min(64, totalAmount);

                if (i + partialStacks == index)
                {
                    exStack.setAmount(exStack.getAmount() - size);
                    if(exStack.getAmount() <= 0)
                    {
                        content.remove(exStack);
                    }
                    break;
                }
                totalAmount -= size;
            }
            i += divisor;
        }


        final int stacksize = stack.stackSize;
        stack.stackSize = 0;
        if (content.containsKey(new ExtendedItemStack(stack, 0)))
        {
            ExtendedItemStack ext = content.remove(new ExtendedItemStack(stack, 0));
            ext.increaseAmount(stacksize);
            content.put(ext, ext);
        }
        else
        {
            final ExtendedItemStack ext = new ExtendedItemStack(stack, stacksize);
            content.put(ext, ext);
        }
    }

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

    public void clear()
    {
        markDirty();
        content.clear();
    }
}

 

Edited by Raycoms
Link to comment
Share on other sites

You're getting a ConcurrentModificationException because you are modifying a collection (by calling content.remove()) while iterating over it (your loop for (final ExtendedItemStack stack : content.values())). To prevent this you need to create and use an iterator directly, and call remove on that instead of on the collection itself.

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



  • Recently Browsing

    • No registered users viewing this page.
  • Posts

    • This is now replaced in the latest version, under Advanced Settings. Not available under the registry anymore.
    • You have to set the java path in your start script
    • i tried that and i got rid of java to install the new one but it still says i have the old one and i cant get the new one because of the old one  
    • I created a boss for Minecraft and when is it called «An unexpected error occurred while trying to run this command» "net.minecraft.world.entity.ai.attributes.attribute instance.m_22100_ (double)" because the return value "net.minecraft.world.entity.monster.zombie.m_21051_(net.minecraft.world.entity.ai.attributes.attribute)" is null. I don't fully understand what the error is. But it seems to be related to attributes. Please help me figure it out   Here is the boss class itself: package org.mymod.afraid; import net.minecraft.world.entity.EntityType; import net.minecraft.world.entity.EquipmentSlot; import net.minecraft.world.entity.ai.attributes.AttributeSupplier; import net.minecraft.world.entity.ai.attributes.Attributes; import net.minecraft.world.entity.ai.goal.*; import net.minecraft.world.entity.ai.goal.target.HurtByTargetGoal; import net.minecraft.world.entity.ai.goal.target.NearestAttackableTargetGoal; import net.minecraft.world.entity.monster.Zombie; import net.minecraft.world.entity.player.Player; import net.minecraft.world.item.ItemStack; import net.minecraft.world.item.Items; import net.minecraft.world.level.Level; import net.minecraft.world.damagesource.DamageSource; import net.minecraft.world.phys.Vec3; import net.minecraft.core.BlockPos; import net.minecraft.world.level.block.Blocks; import net.minecraft.world.entity.projectile.SmallFireball; import org.jetbrains.annotations.NotNull; public class AfraidBoss extends Zombie { private static final int MAX_HEALTH = 1000; private static final double ATTACK_DAMAGE = 10.0D; private static final double FOLLOW_RANGE = 50.0D; private static final double ATTACK_KNOCKBACK = 1.0D; private static final double MOVEMENT_SPEED = 0.25D; private static final int TELEPORT_RADIUS = 20; private static final int FIREBALL_COOLDOWN = 100; // 5 seconds (20 ticks per second) private static final int FIREBALL_COUNT = 3; private int fireballCooldown = 0; private int fireDashCooldown = 0; public AfraidBoss(EntityType<? extends Zombie> type, Level level) { super(type, level); this.setHealth(MAX_HEALTH); this.setItemSlot(EquipmentSlot.MAINHAND, new ItemStack(Items.DIAMOND_SWORD)); this.setItemSlot(EquipmentSlot.OFFHAND, new ItemStack(Items.DIAMOND_SWORD)); } @Override protected void registerGoals() { this.goalSelector.addGoal(1, new MeleeAttackGoal(this, 1.0, true)); this.goalSelector.addGoal(2, new MoveTowardsTargetGoal(this, 1.0, (float) TELEPORT_RADIUS)); this.goalSelector.addGoal(3, new LookAtPlayerGoal(this, Player.class, 8.0F)); this.goalSelector.addGoal(4, new WaterAvoidingRandomStrollGoal(this, 1.0)); this.goalSelector.addGoal(5, new HurtByTargetGoal(this)); this.targetSelector.addGoal(1, new NearestAttackableTargetGoal<>(this, Player.class, true)); } @Override public void aiStep() { super.aiStep(); if (this.getTarget() instanceof Player) { Player player = (Player) this.getTarget(); double distanceToPlayer = this.distanceToSqr(player); // Fire Dash ability if (distanceToPlayer <= TELEPORT_RADIUS * TELEPORT_RADIUS && fireDashCooldown == 0) { this.fireDash(player); fireDashCooldown = 200; // Cooldown for fire dash (10 seconds) } // Fireball attack if (fireballCooldown == 0) { this.shootFireballs(player); fireballCooldown = FIREBALL_COOLDOWN; // Cooldown for fireball attack (5 seconds) } // Decrement cooldowns if (fireDashCooldown > 0) { fireDashCooldown--; } if (fireballCooldown > 0) { fireballCooldown--; } } } private void fireDash(Player player) { Vec3 direction = player.position().subtract(this.position()).normalize(); Vec3 newPos = this.position().add(direction.scale(10)); this.teleportTo(newPos.x, newPos.y, newPos.z); this.createFireTrail(newPos); player.hurt(DamageSource.mobAttack(this), 20.0F); // Damage the player } private void createFireTrail(Vec3 position) { for (int x = -2; x <= 2; x++) { for (int z = -2; z <= 2; z++) { BlockPos firePos = new BlockPos(position.x + x, position.y, position.z + z); this.level.setBlock(firePos, Blocks.FIRE.defaultBlockState(), 11); } } } private void shootFireballs(Player player) { Vec3 direction = player.position().subtract(this.position()).normalize(); for (int i = 0; i < FIREBALL_COUNT; i++) { SmallFireball fireball = new SmallFireball(this.level, this, direction.x, direction.y, direction.z); fireball.setPos(this.getX() + direction.x, this.getY() + direction.y, this.getZ() + direction.z); this.level.addFreshEntity(fireball); } } public static AttributeSupplier.Builder createAttributes() { return Zombie.createMobAttributes() .add(Attributes.MAX_HEALTH, MAX_HEALTH) .add(Attributes.ATTACK_DAMAGE, ATTACK_DAMAGE) .add(Attributes.FOLLOW_RANGE, FOLLOW_RANGE) .add(Attributes.ATTACK_KNOCKBACK, ATTACK_KNOCKBACK) .add(Attributes.MOVEMENT_SPEED, MOVEMENT_SPEED); } @Override public boolean hurt(@NotNull DamageSource source, float amount) { boolean flag = super.hurt(source, amount); if (flag && source.getEntity() instanceof Player) { Player player = (Player) source.getEntity(); if (this.random.nextInt(10) == 0) { this.teleportAndAttack(player); } } return flag; } private void teleportAndAttack(Player player) { Vec3 randomPos = player.position().add((this.random.nextDouble() - 0.5) * 4, 0, (this.random.nextDouble() - 0.5) * 4); if (this.randomTeleport(randomPos.x, randomPos.y, randomPos.z, true)) { player.hurt(DamageSource.mobAttack(this), 10.0F); // Damage the player } } }  
  • Topics

×
×
  • Create New...

Important Information

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