[SOLVED] [1.12.2] Custom player container cannot be cast to ContainerPlayer

[Daeruin]

I have a custom player container that has a full 3x3 crafting grid, and I'm updating to 1.12.2. It worked great before, but now it seems that changes introduced with the recipe book are causing me trouble. Specifically, when pressing E to open the player inventory, I get a crash:

 

com.daeruin.primalcraft.inventory.PrimalContainerPlayer cannot be cast to net.minecraft.inventory.ContainerPlayer

    at net.minecraft.client.gui.inventory.GuiInventory.initGui(GuiInventory.java:72) ~[GuiInventory.class:?]

 

The line in question is a new bit of code for the recipe book GUI that includes a cast to ContainerPlayer. This doesn't work for me since I'm replacing the container player with my custom one. I have tried/considered a few things.

 

1. I tried just overriding the initGui method and casting to my custom player container instead, but there is a call to super.initGUI(). Since I'm extending GuiInventory it ends up processing the super's hard-coded cast to ContainerPlayer anyway. I think I need the call to super, because it goes way up the chain of inheritance to do lots of stuff like displaying potion effects and setting the location of the GUI. Unless maybe I need to duplicate all that stuff in my override instead?
2. I tried making my PrimalContainerPlayer extend ContainerPlayer instead of Container. Unfortunately ContainerPlayer's constructor doesn't work for me since that's where all the inventory slots are created. I need different slots.
3. I considered making my GUI extend InventoryEffectRenderer instead of GuiInventory, but that would require me to copy a ton of vanilla code. That seems like bad style since vanilla code could get change with an update, and my copied code wouldn't automatically reflect the changes. Is that the best choice here, or is there another solution?

 

My player inventory GUI class:

 

Spoiler

public class PrimalGuiInventory extends GuiInventory {

	private float oldMouseX;
	private float oldMouseY;
    private GuiButtonImage recipeButton;
    private final GuiRecipeBook recipeBookGui = new GuiRecipeBook();
    private boolean widthTooNarrow;
	private static final ResourceLocation BACKGROUND_TEXTURE = new ResourceLocation(Primalcraft.MODID, "textures/gui/primal_inventory.png");
    
	public PrimalGuiInventory(EntityPlayer player) 
	{
		super(player);
		this.allowUserInput = true;
	}
	
	// Need to override in order to set values for oldMouseX and oldMouseY, or else the player model in inventory doesn't move
	@Override
    public void drawScreen(int mouseX, int mouseY, float partialTicks)
    {
        super.drawScreen(mouseX, mouseY, partialTicks);
        this.oldMouseX = (float)mouseX;
        this.oldMouseY = (float)mouseY;
    }

	// Same as vanilla, except referring to a different ResourceLocation for the GUI
	@Override
	protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY)
	{
		GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
        this.mc.getTextureManager().bindTexture(BACKGROUND_TEXTURE);
        int i = this.guiLeft;
        int j = this.guiTop;
		this.drawTexturedModalRect(i, j, 0, 0, this.xSize, this.ySize);
		drawEntityOnScreen(i + 51, j + 75, 30, (float)(i + 51) - this.oldMouseX, (float)(j + 75 - 50) - this.oldMouseY, this.mc.player);
	}
	
	// In vanilla, this prints "Crafting" on the screen - override to do nothing
	@Override
	public void drawGuiContainerForegroundLayer(int mouseX, int mouseY)
	{
	}

	@Override
	public void initGui()
	{
		this.buttonList.clear();

		if (this.mc.playerController.isInCreativeMode())
		{
			this.mc.displayGuiScreen(new GuiContainerCreative(this.mc.player));
		}
		else
		{
			super.initGui();
		}

		this.widthTooNarrow = this.width < 379;
		this.recipeBookGui.func_194303_a(this.width, this.height, this.mc, this.widthTooNarrow, ((PrimalContainerPlayer)this.inventorySlots).craftMatrix);
		this.guiLeft = this.recipeBookGui.updateScreenPosition(this.widthTooNarrow, this.width, this.xSize);
		this.recipeButton = new GuiButtonImage(10, this.guiLeft + 104, this.height / 2 - 22, 20, 18, 178, 0, 19, INVENTORY_BACKGROUND);
		this.buttonList.add(this.recipeButton);
	}

}

 

 

My container class:

 

Spoiler

public class PrimalContainerPlayer extends Container {
	
    private static final EntityEquipmentSlot[] VALID_EQUIPMENT_SLOTS = new EntityEquipmentSlot[] {EntityEquipmentSlot.HEAD, EntityEquipmentSlot.CHEST, EntityEquipmentSlot.LEGS, EntityEquipmentSlot.FEET};
    private static final int
            CRAFTING_RESULT = 0,
            MATRIX_START = 1,
            MATRIX_END = MATRIX_START + 3, // First 4 slots of crafting grid, to match up with vanilla's four slots
            ARMOR_START = MATRIX_END + 1,
            ARMOR_END = ARMOR_START + 3,
            INV_START = ARMOR_END + 1,
            INV_END = INV_START + 26,
            HOT_BAR_START = INV_END + 1,
            HOT_BAR_END = HOT_BAR_START + 8,
            OFFHAND_SLOT = HOT_BAR_END + 1,
            MATRIX2_START = HOT_BAR_END + 1,
            MATRIX2_END = MATRIX2_START + 4; // Last 5 slots of crafting grid - new ones at end to keep indices the same
    public final InventoryCrafting craftMatrix = new InventoryCrafting(this, CRAFT_SIZE, CRAFT_SIZE); // 3x3 grid instead of vanilla 2x2
    private final IInventory craftResult = new InventoryCraftResult();
    private final EntityPlayer player;
    private static final int CRAFT_SIZE = 3;

    public PrimalContainerPlayer(final EntityPlayer player, InventoryPlayer playerInventory)
    {

        this.player = player;
		
		// Add slot for crafting result - Index: 0, Position: x=152, y=62
		this.addSlotToContainer(new SlotCrafting(playerInventory.player, this.craftMatrix, this.craftResult, 0, 152, 62));
		
		// Add crafting grid - copied from vanilla but adjusted for 3x3 grid
        // j+i*2 = First pass: i=0, j=0,1,2 = 0,1,2; Second pass: i=1, j=0,1,2 = 3,4,5; Third pass: i=2, j=0,1,2 = 6,7,8
        // Top left corner of crafting grid: x=98, y=8
        List<Slot> matrixSlots = new ArrayList<>();

        for (int i = 0; i < CRAFT_SIZE; ++i)
        {
            for (int j = 0; j < CRAFT_SIZE; ++j)
            {
            	matrixSlots.add(new Slot(this.craftMatrix, j + i * CRAFT_SIZE, 98 + j * 18, 8 + i * 18));
            }
        }

    	// Add enough of the crafting matrix slots to the player inventory container to match what vanilla does
    	// The rest will be added at the end, so they don't throw off the hard-coded re-ordering in GuiContainerCreative
    	for (int x = 0; x < 4; ++x)
    	{
    		this.addSlotToContainer(matrixSlots.get(x));
    	}

        // Add armor slots - copied from vanilla
        for (int k = 0; k < 4; ++k)
        {
            final EntityEquipmentSlot entityequipmentslot = VALID_EQUIPMENT_SLOTS[k];
            this.addSlotToContainer(new Slot(playerInventory, 36 + (3 - k), 8, 8 + k * 18)
            {
                /**
                 * Returns the maximum stack size for a given slot (usually the same as getInventoryStackLimit(), but 1
                 * in the case of armor slots)
                 */
                public int getSlotStackLimit()
                {
                    return 1;
                }
                /**
                 * Check if the stack is allowed to be placed in this slot, used for armor slots as well as furnace
                 * fuel.
                 */
                public boolean isItemValid(ItemStack stack)
                {
                    if (stack.isEmpty())
                    {
                        return false;
                    }
                    else
                    {
                        return stack.getItem().isValidArmor(stack, entityequipmentslot, player);
                    }
                }
                @Nullable
                @SideOnly(Side.CLIENT)
                public String getSlotTexture()
                {
                    return ItemArmor.EMPTY_SLOT_NAMES[entityequipmentslot.getIndex()];
                }
            });
        }

        // Add standard player inventory slots
        for (int l = 0; l < 3; ++l)
        {
            for (int j1 = 0; j1 < 9; ++j1)
            {
                this.addSlotToContainer(new Slot(playerInventory, j1 + (l + 1) * 9, 8 + j1 * 18, 84 + l * 18)
				{
					// Don't allow baskets or lit torches to be placed inside the standard inventory
					@Override
					public boolean isItemValid(ItemStack stack)
					{
                        //noinspection RedundantIfStatement
                        if (stack.isEmpty()
                                || stack.getItem() == Item.getItemFromBlock(PrimalBlockRegistry.MEDIUM_BASKET)
                                || stack.getItem() == Item.getItemFromBlock(PrimalBlockRegistry.LARGE_BASKET)
								|| stack.getItem() == Item.getItemFromBlock(PrimalBlockRegistry.TORCH_LIT))
						{
                            return false;
                        }
						else return true;
					}
				});
            }
        }

        // Add hot bar slots - copied from vanilla
        for (int i1 = 0; i1 < 9; ++i1)
        {
            this.addSlotToContainer(new Slot(playerInventory, i1, 8 + i1 * 18, 142));
        }

        // Add shield slot - copied from vanilla
        this.addSlotToContainer(new Slot(playerInventory, 40, 77, 62)
        {
            @SideOnly(Side.CLIENT)
            public String getSlotTexture()
            {
                return "minecraft:items/empty_armor_slot_shield";
            }
        });
        
        this.onCraftMatrixChanged(this.craftMatrix);
        
        // Add the remaining crafting matrix slots
    	for (int x = 4; x < matrixSlots.size(); ++x)
    	{
    		this.addSlotToContainer(matrixSlots.get(x));
    	}

	} // END OF CONSTRUCTOR


    /**
     * Callback for when the crafting matrix is changed.
     */
    public void onCraftMatrixChanged(IInventory inventoryIn)
    {
        this.craftResult.setInventorySlotContents(0, CraftingManager.findMatchingResult(this.craftMatrix, this.player.world));
    }

    /**
     * Drops everything in the crafting grid out into the world when the container is closed.
     */
    public void onContainerClosed(EntityPlayer playerIn)
    {
        super.onContainerClosed(playerIn);

        for (int i = 0; i < 9; ++i)
        {
            ItemStack itemstack = this.craftMatrix.removeStackFromSlot(i);

            if (!itemstack.isEmpty())
            {
                playerIn.dropItem(itemstack, false);
            }
        }

        this.craftResult.setInventorySlotContents(0, ItemStack.EMPTY);
    }

    /**
     * Determines whether supplied player can use this container
     */
    public boolean canInteractWith(EntityPlayer playerIn)
    {
        return true;
    }

    /**
     * Take a stack from the specified inventory slot. Called when a player shift-clicks on a slot.
     */
    public ItemStack transferStackInSlot(EntityPlayer playerIn, int index)
    {
        ItemStack itemStackCopy = ItemStack.EMPTY;
        Slot slot = this.inventorySlots.get(index);

        if (slot != null && slot.getHasStack())
        {
            ItemStack originalItemStack = slot.getStack();
            itemStackCopy = originalItemStack.copy();
            EntityEquipmentSlot entityequipmentslot = EntityLiving.getSlotForItemStack(itemStackCopy);

         // If item is in crafting result slot - place in standard inventory or hot bar
            if (index == CRAFTING_RESULT) 
            {
                if (!this.mergeItemStack(originalItemStack, INV_START, HOT_BAR_END + 1, true)) // true -> starts trying with HOT_BAR_END and goes to INV_START
                {
                    return ItemStack.EMPTY;
                }

                slot.onSlotChange(originalItemStack, itemStackCopy);
            }
         // If item is in crafting grid - place in standard inventory or hot bar
            else //noinspection ConstantConditions
                if ((index >= MATRIX_START && index <= MATRIX_END) || (index >= MATRIX2_START && index <= MATRIX2_END))
            {
                if (!this.mergeItemStack(originalItemStack, INV_START, HOT_BAR_END + 1, false))
                {
                    return ItemStack.EMPTY;
                }
            }
         // If item is in armor slots - place in standard inventory or hot bar
                else //noinspection ConstantConditions
                    if (index >= ARMOR_START && index <= ARMOR_END)
            {
                if (!this.mergeItemStack(originalItemStack, INV_START, HOT_BAR_END + 1, false))
                {
                    return ItemStack.EMPTY;
                }
            }
         // If the slot clicked contains armor, and the relevant armor slot is empty, add the armor to that slot
                    else if (entityequipmentslot.getSlotType() == EntityEquipmentSlot.Type.ARMOR
                            && !(this.inventorySlots.get(ARMOR_END - entityequipmentslot.getIndex())).getHasStack())
            {
                int i = ARMOR_END - entityequipmentslot.getIndex();

                if (!this.mergeItemStack(originalItemStack, i, i + 1, false))
                {
                    return ItemStack.EMPTY;
                }
            }
         // If the slot  clicked contains an offhand item, and the offhand slot is empty, add the item to the offhand slot
                    else if (entityequipmentslot == EntityEquipmentSlot.OFFHAND && !(this.inventorySlots.get(OFFHAND_SLOT)).getHasStack())
            {
                if (!this.mergeItemStack(originalItemStack, OFFHAND_SLOT, OFFHAND_SLOT + 1, false))
                {
                    return ItemStack.EMPTY;
                }
            }
                    // If item is in standard inventory slots - place in hot bar
                    else //noinspection ConstantConditions
                        if (index >= INV_START && index <= INV_END)
            {
                if (!this.mergeItemStack(originalItemStack, HOT_BAR_START, HOT_BAR_END + 1, false))
                {
                    return ItemStack.EMPTY;
                }
            }
                        // If item is in hot bar slots - place in standard inventory
                        else //noinspection ConstantConditions
                            if (index >= HOT_BAR_START && index <= HOT_BAR_END)
            {
                if (!this.mergeItemStack(originalItemStack, INV_START, INV_END + 1, false))
                {
                    return ItemStack.EMPTY;
                }
            }
                            else if (!this.mergeItemStack(originalItemStack, INV_START, HOT_BAR_END + 1, false))
            {
                return ItemStack.EMPTY;
            }

            if (originalItemStack.getCount() == 0)
            {
                slot.putStack(ItemStack.EMPTY);
            }
            else
            {
                slot.onSlotChanged();
            }

            if (originalItemStack.getCount() == itemStackCopy.getCount())
            {
                return ItemStack.EMPTY;
            }

            slot.onTake(playerIn, originalItemStack);
        }

        return itemStackCopy;
    }

    /**
     * Called to determine if the current slot is valid for the stack merging (double-click) code. The stack passed in
     * is null for the initial slot that was double-clicked.
     */
    public boolean canMergeSlot(ItemStack stack, Slot slotIn)
    {
        return slotIn.inventory != this.craftResult && super.canMergeSlot(stack, slotIn);
    }
    
}

 

 

Edited February 12, 2018 by Daeruin
Formatting

[Draco18s]

5 minutes ago, Daeruin said:

extends Container

Cough

extends PlayerContainer

Cough

[Daeruin]

2 minutes ago, Draco18s said:

Cough

extends PlayerContainer

Cough

 

Tried it (I assume you mean ContainerPlayer). ContainerPlayer's constructor doesn't work for me since I'm adding and moving around slots.

[Draco18s]

You still need to extend it and deal with it.

[Daeruin]

6 hours ago, Draco18s said:

You still need to extend it and deal with it.

 

Well, that was easier than I thought it would be. You made me awfully grumpy at first, but after taking your word for it and thinking about it for a while, I realized that after calling the super's constructor, I could just clear all the old inventory slots using List::clear and start over, so all my old code still works fine.