So, in my Inventory class for my custom inventory, I am using #setInventorySlotContents to detect an item in the slot, and perform an action accordingly. Problem is, it is only detecting one item. here is what my method looks like:

public void setInventorySlotContents(int slot, ItemStack stack) {
	this.inventory[slot] = stack;

	if(stack != null && stack.stackSize > this.getInventoryStackLimit()) {
		stack.stackSize = this.getInventoryStackLimit();
	}

	if(getStackInSlot(SLOT_BACKPACK) != null && getStackInSlot(SLOT_BACKPACK).getItem() instanceof ItemBackpack) {
		if(!player.worldObj.isRemote) {
			System.out.println("World is not remote");

			ExtendedPlayer props = ExtendedPlayer.get(player);

			if(props.get(player) != null) {

				System.out.println("Player props are not null");

				if(getStackInSlot(SLOT_BACKPACK).getItem() instanceof ItemSmallBackpack) {
					System.out.println("Small Backpack detected!");

					props.setMaxWeight(200);
				} 

				if(getStackInSlot(SLOT_BACKPACK).getItem() instanceof ItemMediumBackpack) {
					System.out.println("Medium Backpack detected!");

					props.setMaxWeight(250);
				}

				if(getStackInSlot(SLOT_BACKPACK).getItem() instanceof ItemLargeBackpack) {
					System.out.println("Large Backpack detected!");

					props.setMaxWeight(300);
				}
			}
		}

		System.out.println("BACKPACK IN SLOT!");
	}else {
		if(!player.worldObj.isRemote) {

			ExtendedPlayer props = ExtendedPlayer.get(player);

			if(props.get(player) != null) {
				props.setMaxWeight(150);
			}
		}
	}

	this.markDirty();
}

 

The problem is where I am checking for an item in "SLOT_BACKPACK" (it is 0. I just use a constant for organization). The items I check for all extend a base called "ItemBackpack", and I would think using "instanceof" to check for it would be enough. But no matter what of the three items I put, it will always seem to return as the ItemSmallBackpack being in the slot. Am I checking for the items wrong? Would using a switch fix the problem?

Why not create a getMaxWeight() method to ItemBackpack, get the item, cast it, then ask the backpack what it's max weight is.

In addition to what Draco said, why not use the 'slot' and 'stack' parameters from the method? Is 'SLOT_BACKPACK' the only slot that will affect weight? If so:

if (slot == SLOT_BACKPACK) {
  // you already have the ItemStack in the slot, it is 'stack':
  if (stack == null || !(stack.getItem() instanceof ItemBackpack)) {
    // reset player's carry weight
  } else {
     // example only
     player.carryWeight += ((ItemBackpack) stack.getItem()).getCarryWeight(stack);
  }
}

Even better would be to create an interface such as ICarryWeight - then you could have any number of item types that provide carry weight modifiers.

 

Even better than that would be to create a SharedMonsterAttribute for carry weight, then those same items could be in ANY armor or held-item slot (and possibly Baubles slots, haven't worked with it though) and they would affect your carry weight.

I was working on this at 4am, so no wonder I forgot about the parameters. I honestly have never understood how Interfaces truly work. I know they can help me greatly, but all I know is they are abstract, and used to implement methods I am guessing you call in other classes?

Alright, I researched interfaces a tad bit, and made one for my base class. And, after all of that, THE SAME ERROR PERSISTS. Like I said, I have three Backpacks that extend the base of ItemBackpack (ItemSmallBackpack, ItemMediumBackpack, and ItemLargeBackpack). Now, I would think, considering these are three separate classes, it wouldn't be too difficult to actually get the right item, I would be wrong. Here are the item classes, the base, the interface, and the new #setInventorySlotContents. Thank you for any help you can provide.

 

ItemSmallBackpack:

package com.happykiller.weightlimit.items;

public class ItemSmallBackpack extends ItemBackpack {

public ItemSmallBackpack() {
	this.setMaxCarryWeight(200);
}
}

 

ItemMediumBackpack:

package com.happykiller.weightlimit.items;

public class ItemMediumBackpack extends ItemBackpack {

public ItemMediumBackpack() {
	this.setMaxCarryWeight(280);
}
}

 

ItemLargeBackpack:

package com.happykiller.weightlimit.items;

public class ItemLargeBackpack extends ItemBackpack {

public ItemLargeBackpack() {
	this.setMaxCarryWeight(380);
}
}

 

ItemBackpack:

package com.happykiller.weightlimit.items;

import java.util.List;

import com.happykiller.weightlimit.main.interfaces.ICarryWeightModifier;
import com.happykiller.weightlimit.player.ExtendedPlayer;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.world.World;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

public class ItemBackpack extends Item implements ICarryWeightModifier {

protected int maxWeightModifier = 150;

public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) {
	if(!world.isRemote) {
		ExtendedPlayer props = ExtendedPlayer.get(player);

		if(!player.isSneaking()) {
			props.addWeight(1);
			System.out.println("Current Weight: " + props.getCurrentWeight());
		}else {
			props.removeAllWeight();
			System.out.println("Current Weight: " + props.getCurrentWeight());
		}
	}

	return stack;
}

@SideOnly(Side.CLIENT)
public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean advanced) {

}

public int setMaxCarryWeight(int newMaxWeight) {
	if(newMaxWeight > 0) {
		this.maxWeightModifier = newMaxWeight;
	}else {
		this.maxWeightModifier = 150;
	}

	return this.maxWeightModifier;
}

public int getMaxCarryWeight() {
	return this.maxWeightModifier;
}

public int getMaxCarryWeightForStack(ItemStack stack) {
	int stackModifier = 150;

	if(stack.getItem() instanceof ItemBackpack) {
		stackModifier = ((ItemBackpack)stack.getItem()).getMaxCarryWeight();
	}else {
		System.out.println("ERROR: Stack was not an extension of ItemBackpack in SLOT_BACKPACK!");
	}

	return stackModifier;
}
}

 

ICarryWeightModifier:

package com.happykiller.weightlimit.main.interfaces;

import net.minecraft.item.ItemStack;

public interface ICarryWeightModifier {

public int setMaxCarryWeight(int newMaxWeight);

public int getMaxCarryWeightForStack(ItemStack stack);

public int getMaxCarryWeight();
}

 

New #setInventorySlotContents:

public void setInventorySlotContents(int slot, ItemStack stack) {
	this.inventory[slot] = stack;

	if(stack != null && stack.stackSize > this.getInventoryStackLimit()) {
		stack.stackSize = this.getInventoryStackLimit();
	}

	if(slot == SLOT_BACKPACK) {
		if(!player.worldObj.isRemote) {

			ExtendedPlayer props = ExtendedPlayer.get(player);

			if(props.get(player) != null) {
				if(stack == null || !(stack.getItem() instanceof ItemBackpack)) {
					props.setMaxWeight(150);
				}else {
					int newMaxWeight = ((ItemBackpack)stack.getItem()).getMaxCarryWeightForStack(stack);

					System.out.println("Stack in use: " + stack.getItem());

					System.out.println("Max weight from interface is: " + newMaxWeight);

					props.setMaxWeight(newMaxWeight);
				}
			}
		}
	}

	this.markDirty();
}

My God, all this time and effort to realize I was registering all three items with the ItemSmallBackpack class. Thank you for showing me an easier way of modifying weight limits, sorry for my idiocy!

I was working on this at 4am, so no wonder I forgot about the parameters. I honestly have never understood how Interfaces truly work. I know they can help me greatly, but all I know is they are abstract, and used to implement methods I am guessing you call in other classes?

 

Interfaces exist to allow multiple objects with different inheritance hierarchies to be treated as "the same" due to the contract granted by the interface.

Yes, I went through some Java docs online to figure it out after hearing I should use it. Basically, if we have an interface called "IVehicle", and our class "Car" implements it, if a method requires a class from IVehicle as a param, you can give it the Car class and it works, correct?

Yes, I went through some Java docs online to figure it out after hearing I should use it. Basically, if we have an interface called "IVehicle", and our class "Car" implements it, if a method requires a class from IVehicle as a param, you can give it the Car class and it works, correct?

 

Yep. You could also pass CardboardBoxSpaceShip as long as it also implements IVehicle.

Thanks for the help. Will help me a lot throughout my current mod creation.