minecraft-source/src/net/minecraft/world/SimpleContainer.java

package net.minecraft.world;

import java.util.stream.Collector;
import java.util.stream.Collectors;
import net.minecraft.world.entity.player.StackedContents;
import net.minecraft.world.entity.player.Player;
import java.util.Iterator;
import net.minecraft.world.level.ItemLike;
import net.minecraft.world.item.Item;
import com.google.common.collect.Lists;
import java.util.List;
import net.minecraft.world.item.ItemStack;
import net.minecraft.core.NonNullList;
import net.minecraft.world.inventory.StackedContentsCompatible;

public class SimpleContainer implements Container, StackedContentsCompatible {
    private final int size;
    private final NonNullList<ItemStack> items;
    private List<ContainerListener> listeners;
    
    public SimpleContainer(final int integer) {
        this.size = integer;
        this.items = NonNullList.<ItemStack>withSize(integer, ItemStack.EMPTY);
    }
    
    public SimpleContainer(final ItemStack... arr) {
        this.size = arr.length;
        this.items = NonNullList.<ItemStack>of(ItemStack.EMPTY, arr);
    }
    
    public void addListener(final ContainerListener ajd) {
        if (this.listeners == null) {
            this.listeners = Lists.newArrayList();
        }
        this.listeners.add(ajd);
    }
    
    public void removeListener(final ContainerListener ajd) {
        this.listeners.remove(ajd);
    }
    
    @Override
    public ItemStack getItem(final int integer) {
        if (integer < 0 || integer >= this.items.size()) {
            return ItemStack.EMPTY;
        }
        return this.items.get(integer);
    }
    
    @Override
    public ItemStack removeItem(final int integer1, final int integer2) {
        final ItemStack bek4 = ContainerHelper.removeItem(this.items, integer1, integer2);
        if (!bek4.isEmpty()) {
            this.setChanged();
        }
        return bek4;
    }
    
    public ItemStack removeItemType(final Item bef, final int integer) {
        final ItemStack bek4 = new ItemStack(bef, 0);
        for (int integer2 = this.size - 1; integer2 >= 0; --integer2) {
            final ItemStack bek5 = this.getItem(integer2);
            if (bek5.getItem().equals(bef)) {
                final int integer3 = integer - bek4.getCount();
                final ItemStack bek6 = bek5.split(integer3);
                bek4.grow(bek6.getCount());
                if (bek4.getCount() == integer) {
                    break;
                }
            }
        }
        if (!bek4.isEmpty()) {
            this.setChanged();
        }
        return bek4;
    }
    
    public ItemStack addItem(final ItemStack bek) {
        final ItemStack bek2 = bek.copy();
        this.moveItemToOccupiedSlotsWithSameType(bek2);
        if (bek2.isEmpty()) {
            return ItemStack.EMPTY;
        }
        this.moveItemToEmptySlots(bek2);
        if (bek2.isEmpty()) {
            return ItemStack.EMPTY;
        }
        return bek2;
    }
    
    @Override
    public ItemStack removeItemNoUpdate(final int integer) {
        final ItemStack bek3 = this.items.get(integer);
        if (bek3.isEmpty()) {
            return ItemStack.EMPTY;
        }
        this.items.set(integer, ItemStack.EMPTY);
        return bek3;
    }
    
    @Override
    public void setItem(final int integer, final ItemStack bek) {
        this.items.set(integer, bek);
        if (!bek.isEmpty() && bek.getCount() > this.getMaxStackSize()) {
            bek.setCount(this.getMaxStackSize());
        }
        this.setChanged();
    }
    
    @Override
    public int getContainerSize() {
        return this.size;
    }
    
    @Override
    public boolean isEmpty() {
        for (final ItemStack bek3 : this.items) {
            if (!bek3.isEmpty()) {
                return false;
            }
        }
        return true;
    }
    
    @Override
    public void setChanged() {
        if (this.listeners != null) {
            for (final ContainerListener ajd3 : this.listeners) {
                ajd3.containerChanged(this);
            }
        }
    }
    
    @Override
    public boolean stillValid(final Player ayg) {
        return true;
    }
    
    @Override
    public void clearContent() {
        this.items.clear();
        this.setChanged();
    }
    
    @Override
    public void fillStackedContents(final StackedContents ayi) {
        for (final ItemStack bek4 : this.items) {
            ayi.accountStack(bek4);
        }
    }
    
    @Override
    public String toString() {
        return this.items.stream().filter(bek -> !bek.isEmpty()).collect(Collectors.toList()).toString();
    }
    
    private void moveItemToEmptySlots(final ItemStack bek) {
        for (int integer3 = 0; integer3 < this.size; ++integer3) {
            final ItemStack bek2 = this.getItem(integer3);
            if (bek2.isEmpty()) {
                this.setItem(integer3, bek.copy());
                bek.setCount(0);
                return;
            }
        }
    }
    
    private void moveItemToOccupiedSlotsWithSameType(final ItemStack bek) {
        for (int integer3 = 0; integer3 < this.size; ++integer3) {
            final ItemStack bek2 = this.getItem(integer3);
            if (ItemStack.isSame(bek2, bek)) {
                this.moveItemsBetweenStacks(bek, bek2);
                if (bek.isEmpty()) {
                    return;
                }
            }
        }
    }
    
    private void moveItemsBetweenStacks(final ItemStack bek1, final ItemStack bek2) {
        final int integer4 = Math.min(this.getMaxStackSize(), bek2.getMaxStackSize());
        final int integer5 = Math.min(bek1.getCount(), integer4 - bek2.getCount());
        if (integer5 > 0) {
            bek2.grow(integer5);
            bek1.shrink(integer5);
            this.setChanged();
        }
    }
}