[1.16.4] what difference between custom slots and EquipmentSlotType

[Klarks]

In my container class ive created slots 

private static final EquipmentSlotType[] VALID_EQUIPMENT_SLOTS = new EquipmentSlotType[]{EquipmentSlotType.HEAD, EquipmentSlotType.CHEST, EquipmentSlotType.LEGS, EquipmentSlotType.FEET};

 
en.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY).ifPresent(h -> {
     int index =0;
     for(int i = 8;i < 64;i+=18)
     {
         final EquipmentSlotType equipmentslottype = VALID_EQUIPMENT_SLOTS[index];
         addSlot(new SlotItemHandler(h,index,8,i)
         {
             public int getSlotStackLimit() {
                 return 1;
             }

             public boolean isItemValid(ItemStack stack) {
                 return stack.canEquip(equipmentslottype,en);
             }


             public boolean canTakeStack(PlayerEntity playerIn) {
                 ItemStack itemstack = this.getStack();
                 return !itemstack.isEmpty() && !playerIn.isCreative() && EnchantmentHelper.hasBindingCurse(itemstack) ? false : super.canTakeStack(playerIn);
             }

             @OnlyIn(Dist.CLIENT)
             public Pair<ResourceLocation, ResourceLocation> getBackground() {
                 return Pair.of(MyModContainer.LOCATION_BLOCKS_TEXTURE, MyModContainer.ARMOR_SLOT_TEXTURES[equipmentslottype.getIndex()]);
             }
         });
    index++;
     }
});

 

In my entity class i can use hadler to set and get my items from slots

    public ItemStackHandler handler;

    private ItemStackHandler getHandler()
    {
        if(handler == null)
        {
            handler = new ItemStackHandler(4);
        }
        return handler;
    }




    @Override
    public ILivingEntityData onInitialSpawn(IServerWorld worldIn, DifficultyInstance difficultyIn, SpawnReason reason, @Nullable ILivingEntityData spawnDataIn, @Nullable CompoundNBT dataTag) {
handler.setStackInSlot(0,new ItemStack(Items.DIAMOND_HELMET));




        return super.onInitialSpawn(worldIn, difficultyIn, reason, spawnDataIn, dataTag);
    }

 

But i cant get an itemstack from my handler from my layer model class. the game crashes. but i can get it from EquipmentSlotType but i dont need it because i store items in my container class slots

public class top1Layer  extends LayerRenderer<MyEntity, MobModel<MyEntity>> {
    private static final ResourceLocation TEXTURE_TOP1 = new ResourceLocation(Main.MODID,"textures/entity/mob/monster.png");

    public top1Layer(IEntityRenderer<MyEntity, MobModel<MyEntity>> entityRendererIn) {
        super(entityRendererIn);
    }





    @Override
    public void render(MatrixStack matrixStackIn, IRenderTypeBuffer bufferIn, int packedLightIn, MyEntity entitylivingbaseIn, float limbSwing, float limbSwingAmount, float partialTicks, float ageInTicks, float netHeadYaw, float headPitch) {
       ItemStack itemstack = entitylivingbaseIn.handler.getStackInSlot(0);
    }
}

[Klarks]

Return here?

public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {


    if(cap == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
    {
      
  return  LazyOptional.of(() -> (T) getHandler()); //Here?
    }
    return super.getCapability(cap, side);
}

[Klarks]

should  this line return me IItemHandler instances for armor and held inventories?

return  LazyOptional.of(() -> (T) getHandler());

Edited January 21, 2021 by Klarks

[Klarks]

those handlers ?

public <T> net.minecraftforge.common.util.LazyOptional<T> getCapability(net.minecraftforge.common.capabilities.Capability<T> capability, @Nullable Direction facing) {
   if (this.isAlive() && capability == net.minecraftforge.items.CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
      if (facing == null) return handlers[2].cast();
      else if (facing.getAxis().isVertical()) return handlers[0].cast();
      else if (facing.getAxis().isHorizontal()) return handlers[1].cast();
   }
   return super.getCapability(capability, facing);
}

 

[Klarks]

I dont understand how i can get them from my class

[Klarks]

Like this

public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {


    if(cap == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
    {
        return getCapability(cap,side).cast();
     
    }
    return super.getCapability(cap, side);
}

[Klarks]

To get my itemhandler.i need to get default living entity slots and my custom slots

[Klarks]

Like this?
 

public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {


    if(cap == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
    {
        super.getCapability(cap, side);
        return  LazyOptional.of(() -> (T) getHandler());
    }
    return super.getCapability(cap, side);
}

[Klarks]

I dont even understand what type of value is this. What LazyOptional do, how it works and how i can get ItemHandler from this. 

[Klarks]

Do i need to return a list of ItemHandlers?

[Klarks]

I guess i did it.

public <T> LazyOptional<T> create(LivingEntity entity)
{
    LazyOptional<IItemHandlerModifiable>[] ret = new LazyOptional[2];
    ret[0] = LazyOptional.of(() ->  getHandler());
    ret[1] = LazyOptional.of(() -> new EntityArmorInvWrapper(entity));
    return LazyOptional.of(() -> (T)new CombinedInvWrapper(ret[0].orElse(null), ret[1].orElse(null)));
}

public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {


    if(cap == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
    {
      //  super.getCapability(cap, side).;
        return create(this);
    }
    return super.getCapability(cap, side);
}

 

But how would a slot know if its a default or a custom slot
 

en.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY).ifPresent(h -> {
    int index = 0;
    for(int i =8;i < 63;i+=18)
    {
        final EquipmentSlotType equipmentslottype = VALID_EQUIPMENT_SLOTS[index];
        addSlot(new SlotItemHandler(h,index,8,i){

            public int getSlotStackLimit() {
                return 1;
            }


            public boolean isItemValid(ItemStack stack) {
                return stack.canEquip(equipmentslottype, en);
            }

            public boolean canTakeStack(PlayerEntity playerIn) {
                ItemStack itemstack = this.getStack();
                return !itemstack.isEmpty() && !playerIn.isCreative() && EnchantmentHelper.hasBindingCurse(itemstack) ? false : super.canTakeStack(playerIn);
            }

            @OnlyIn(Dist.CLIENT)
            public Pair<ResourceLocation, ResourceLocation> getBackground() {
                return Pair.of(PlayerContainer.LOCATION_BLOCKS_TEXTURE, MyModContainer.ARMOR_SLOT_TEXTURES[equipmentslottype.getIndex()]);
            }
        });
        index++;
    }
});

[Klarks]

I created now.

public MyEntity(EntityType<? extends MyEntity> type, World worldIn)
{
    super(type, worldIn);
   handler = getHandler();
    optional = create(this);
}

do i need this?

public <T> LazyOptional<T> create(LivingEntity entity)
{
    LazyOptional<IItemHandlerModifiable>[] ret = new LazyOptional[2];
    ret[0] = LazyOptional.of(() ->  getHandler());
    ret[1] = LazyOptional.of(() -> new EntityArmorInvWrapper(entity));
    return LazyOptional.of(() -> (T)new CombinedInvWrapper(ret[0].orElse(null), ret[1].orElse(null)));
}

 

here i got default handler 
 

public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {


    if(cap == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
    {
        defHandler = (ItemStackHandler) super.getCapability(cap,side).orElse(null);
        return create(this);
    }
    return super.getCapability(cap, side);
}

public ItemStack func_213803_dV() {
    return this.getItemStackFromSlot(EquipmentSlotType.CHEST);
}

Am i going right?

[Draco18s]

31 minutes ago, Klarks said:

return LazyOptional.of(() -> (T)new CombinedInvWrapper(ret[0].orElse(null), ret[1].orElse(null)));

Why did you create two lazy optionals, then unbox them to pass into the CombinedInvWrapper?

(Not to mention using an array to store the local results? Why!?)

return LazyOptional.of(() -> (T)new CombinedInvWrapper(getHandler(), new EntityArmorInvWrapper(entity)));

Edited January 21, 2021 by Draco18s

[Klarks]

If super.getCapability give me the default handlers so what new EntityArmorInvWrapper(entity) do 

[Klarks]

Why i need cal super.getCapability? Is new EntityArmorInvWrapper(entity) doing same thing?

LivingEntity. it returns handlers which are LazyOptional<IItemHandlerModifiable>[] and they contains same things what i have already created

private final net.minecraftforge.common.util.LazyOptional<?>[] handlers = net.minecraftforge.items.wrapper.EntityEquipmentInvWrapper.create(this);

public <T> net.minecraftforge.common.util.LazyOptional<T> getCapability(net.minecraftforge.common.capabilities.Capability<T> capability, @Nullable Direction facing) {
   if (this.isAlive() && capability == net.minecraftforge.items.CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
      if (facing == null) return handlers[2].cast();
      else if (facing.getAxis().isVertical()) return handlers[0].cast();
      else if (facing.getAxis().isHorizontal()) return handlers[1].cast();
   }
   return super.getCapability(capability, facing);

 

EntityEquipmentInvWrapper

public static LazyOptional<IItemHandlerModifiable>[] create(LivingEntity entity)
{
    @SuppressWarnings("unchecked")
    LazyOptional<IItemHandlerModifiable>[] ret = new LazyOptional[3];
    ret[0] = LazyOptional.of(() -> new EntityHandsInvWrapper(entity));
    ret[1] = LazyOptional.of(() -> new EntityArmorInvWrapper(entity));
    ret[2] = LazyOptional.of(() -> new CombinedInvWrapper(ret[0].orElse(null), ret[1].orElse(null)));
    return ret;
}

[Klarks]

I have 4 default slots (head,chest,legs,feet) and 1 my custom slot for anty item

[Klarks]

I didnt got 2 things.

1.my handleCustom is a ItemStackHandler, i cant combined it with handlerDefault they are different classes

2. How can i override in the constructor and what is facing

public ItemStackHandler handlerCustom;
public IItemHandler handlerDefault;
public IItemHandler both;
LazyOptional<IItemHandler> optional;
public MyEntity(EntityType<? extends MyEntity> type, World worldIn)
{
    super(type, worldIn);
    handlerCustom = new ItemStackHandler(1); //1
    handlerDefault = super.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY,Direction.EAST).orElse(null);
    both = new CombinedInvWrapper(handlerCustom,handlerDefault);
    optional = LazyOptional.of(() -> both);
}

[Draco18s]

You should probably also use orElseThrow instead of orElse(null).

[Klarks]

My constructor looks like this now.

public ItemStackHandler handlerCustom;
public IItemHandler handlerDefault;
public IItemHandler both;
LazyOptional<IItemHandler> optional;
public WhoreEntity(EntityType<? extends WhoreEntity> type, World worldIn)
{
    super(type, worldIn);
    handlerCustom = new ItemStackHandler(1); //1
    handlerDefault = super.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY,Direction.EAST).orElseThrow(null);
    both = new CombinedInvWrapper(handlerCustom, ((IItemHandlerModifiable) handlerDefault));
    optional = LazyOptional.of(() -> both);


}

 

And my Override getCapability. I dont sure what is facing means

@Nonnull
@Override
public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {
    if(cap == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY && side != null)
    {
            return (LazyOptional<T>)optional;
    }
    return super.getCapability(cap, side);
}

 

Did i do that all right?

[Klarks]

Its kinda working now but how can i choose which of a default ones slots i want to use. For example i dont need head slot or i just shouldn't use it as an index in my container?
Now i get the facing thing 
null = hands and armor

vertical = hands

horizontal = armor

Edited January 23, 2021 by Klarks

[Klarks]

Thank you for explaining all this to me.