mirror of
https://github.com/MinecraftForge/MinecraftForge.git
synced 2026-11-18 19:39:22 +00:00
Update to Official classnames Patchwork Make the game compile and run Merge in the new HUD overlay API Merge in the new render properties API PEEL Use Gradle 7.2 snapshot to fix eclipse integration bug in 7.1, Would use 7.0 but FG needs 7.1 for some reason. New FML installer Update to 1.17.1 Co-authored-by: LexManos <[email protected]> Co-authored-by: SizableShrimp <[email protected]> Co-authored-by: cpw <[email protected]> Co-authored-by: Curle <[email protected]> Co-authored-by: Unnoen <[email protected]> Co-authored-by: covers1624 <[email protected]> Co-authored-by: DaemonUmbra <[email protected]> Co-authored-by: gigaherz <[email protected]> Signed-off-by: SizableShrimp <[email protected]>
234 lines
7.9 KiB
Java
234 lines
7.9 KiB
Java
/*
|
|
* Minecraft Forge
|
|
* Copyright (c) 2016-2021.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation version 2.1
|
|
* of the License.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
package net.minecraftforge.items;
|
|
|
|
import net.minecraft.world.entity.item.ItemEntity;
|
|
import net.minecraft.world.entity.player.Player;
|
|
import net.minecraft.sounds.SoundEvents;
|
|
import net.minecraft.world.item.ItemStack;
|
|
import net.minecraft.sounds.SoundSource;
|
|
import net.minecraft.util.Mth;
|
|
import net.minecraft.world.level.Level;
|
|
import net.minecraftforge.items.wrapper.PlayerMainInvWrapper;
|
|
|
|
import javax.annotation.Nonnull;
|
|
import javax.annotation.Nullable;
|
|
|
|
public class ItemHandlerHelper
|
|
{
|
|
@Nonnull
|
|
public static ItemStack insertItem(IItemHandler dest, @Nonnull ItemStack stack, boolean simulate)
|
|
{
|
|
if (dest == null || stack.isEmpty())
|
|
return stack;
|
|
|
|
for (int i = 0; i < dest.getSlots(); i++)
|
|
{
|
|
stack = dest.insertItem(i, stack, simulate);
|
|
if (stack.isEmpty())
|
|
{
|
|
return ItemStack.EMPTY;
|
|
}
|
|
}
|
|
|
|
return stack;
|
|
}
|
|
|
|
public static boolean canItemStacksStack(@Nonnull ItemStack a, @Nonnull ItemStack b)
|
|
{
|
|
if (a.isEmpty() || !a.sameItem(b) || a.hasTag() != b.hasTag())
|
|
return false;
|
|
|
|
return (!a.hasTag() || a.getTag().equals(b.getTag())) && a.areCapsCompatible(b);
|
|
}
|
|
|
|
/**
|
|
* A relaxed version of canItemStacksStack that stacks itemstacks with different metadata if they don't have subtypes.
|
|
* This usually only applies when players pick up items.
|
|
*/
|
|
public static boolean canItemStacksStackRelaxed(@Nonnull ItemStack a, @Nonnull ItemStack b)
|
|
{
|
|
if (a.isEmpty() || b.isEmpty() || a.getItem() != b.getItem())
|
|
return false;
|
|
|
|
if (!a.isStackable())
|
|
return false;
|
|
|
|
// Metadata value only matters when the item has subtypes
|
|
// Vanilla stacks non-subtype items with different metadata together
|
|
// TODO Item subtypes, is this still necessary?
|
|
/* e.g. a stick with metadata 0 and a stick with metadata 1 stack
|
|
if (a.getHasSubtypes() && a.getMetadata() != b.getMetadata())
|
|
return false;
|
|
*/
|
|
if (a.hasTag() != b.hasTag())
|
|
return false;
|
|
|
|
return (!a.hasTag() || a.getTag().equals(b.getTag())) && a.areCapsCompatible(b);
|
|
}
|
|
|
|
@Nonnull
|
|
public static ItemStack copyStackWithSize(@Nonnull ItemStack itemStack, int size)
|
|
{
|
|
if (size == 0)
|
|
return ItemStack.EMPTY;
|
|
ItemStack copy = itemStack.copy();
|
|
copy.setCount(size);
|
|
return copy;
|
|
}
|
|
|
|
/**
|
|
* Inserts the ItemStack into the inventory, filling up already present stacks first.
|
|
* This is equivalent to the behaviour of a player picking up an item.
|
|
* Note: This function stacks items without subtypes with different metadata together.
|
|
*/
|
|
@Nonnull
|
|
public static ItemStack insertItemStacked(IItemHandler inventory, @Nonnull ItemStack stack, boolean simulate)
|
|
{
|
|
if (inventory == null || stack.isEmpty())
|
|
return stack;
|
|
|
|
// not stackable -> just insert into a new slot
|
|
if (!stack.isStackable())
|
|
{
|
|
return insertItem(inventory, stack, simulate);
|
|
}
|
|
|
|
int sizeInventory = inventory.getSlots();
|
|
|
|
// go through the inventory and try to fill up already existing items
|
|
for (int i = 0; i < sizeInventory; i++)
|
|
{
|
|
ItemStack slot = inventory.getStackInSlot(i);
|
|
if (canItemStacksStackRelaxed(slot, stack))
|
|
{
|
|
stack = inventory.insertItem(i, stack, simulate);
|
|
|
|
if (stack.isEmpty())
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// insert remainder into empty slots
|
|
if (!stack.isEmpty())
|
|
{
|
|
// find empty slot
|
|
for (int i = 0; i < sizeInventory; i++)
|
|
{
|
|
if (inventory.getStackInSlot(i).isEmpty())
|
|
{
|
|
stack = inventory.insertItem(i, stack, simulate);
|
|
if (stack.isEmpty())
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return stack;
|
|
}
|
|
|
|
/** giveItemToPlayer without preferred slot */
|
|
public static void giveItemToPlayer(Player player, @Nonnull ItemStack stack) {
|
|
giveItemToPlayer(player, stack, -1);
|
|
}
|
|
|
|
/**
|
|
* Inserts the given itemstack into the players inventory.
|
|
* If the inventory can't hold it, the item will be dropped in the world at the players position.
|
|
*
|
|
* @param player The player to give the item to
|
|
* @param stack The itemstack to insert
|
|
*/
|
|
public static void giveItemToPlayer(Player player, @Nonnull ItemStack stack, int preferredSlot)
|
|
{
|
|
if (stack.isEmpty()) return;
|
|
|
|
IItemHandler inventory = new PlayerMainInvWrapper(player.getInventory());
|
|
Level world = player.level;
|
|
|
|
// try adding it into the inventory
|
|
ItemStack remainder = stack;
|
|
// insert into preferred slot first
|
|
if (preferredSlot >= 0 && preferredSlot < inventory.getSlots())
|
|
{
|
|
remainder = inventory.insertItem(preferredSlot, stack, false);
|
|
}
|
|
// then into the inventory in general
|
|
if (!remainder.isEmpty())
|
|
{
|
|
remainder = insertItemStacked(inventory, remainder, false);
|
|
}
|
|
|
|
// play sound if something got picked up
|
|
if (remainder.isEmpty() || remainder.getCount() != stack.getCount())
|
|
{
|
|
world.playSound(null, player.getX(), player.getY() + 0.5, player.getZ(),
|
|
SoundEvents.ITEM_PICKUP, SoundSource.PLAYERS, 0.2F, ((world.random.nextFloat() - world.random.nextFloat()) * 0.7F + 1.0F) * 2.0F);
|
|
}
|
|
|
|
// drop remaining itemstack into the world
|
|
if (!remainder.isEmpty() && !world.isClientSide)
|
|
{
|
|
ItemEntity entityitem = new ItemEntity(world, player.getX(), player.getY() + 0.5, player.getZ(), remainder);
|
|
entityitem.setPickUpDelay(40);
|
|
entityitem.setDeltaMovement(entityitem.getDeltaMovement().multiply(0, 1, 0));
|
|
|
|
world.addFreshEntity(entityitem);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method uses the standard vanilla algorithm to calculate a comparator output for how "full" the inventory is.
|
|
* This method is an adaptation of Container#calcRedstoneFromInventory(IInventory).
|
|
* @param inv The inventory handler to test.
|
|
* @return A redstone value in the range [0,15] representing how "full" this inventory is.
|
|
*/
|
|
public static int calcRedstoneFromInventory(@Nullable IItemHandler inv)
|
|
{
|
|
if (inv == null)
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
int itemsFound = 0;
|
|
float proportion = 0.0F;
|
|
|
|
for (int j = 0; j < inv.getSlots(); ++j)
|
|
{
|
|
ItemStack itemstack = inv.getStackInSlot(j);
|
|
|
|
if (!itemstack.isEmpty())
|
|
{
|
|
proportion += (float)itemstack.getCount() / (float)Math.min(inv.getSlotLimit(j), itemstack.getMaxStackSize());
|
|
++itemsFound;
|
|
}
|
|
}
|
|
|
|
proportion = proportion / (float)inv.getSlots();
|
|
return Mth.floor(proportion * 14.0F) + (itemsFound > 0 ? 1 : 0);
|
|
}
|
|
}
|
|
}
|