Sebastian Hartte
858826d1fa
Fix Vibration Chamber inventory filter. Fix Molecular Assembler inventory filter.
278 lines
9.9 KiB
Java
278 lines
9.9 KiB
Java
/*
|
|
* This file is part of Applied Energistics 2.
|
|
* Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved.
|
|
*
|
|
* Applied Energistics 2 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, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Applied Energistics 2 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 Applied Energistics 2. If not, see <http://www.gnu.org/licenses/lgpl>.
|
|
*/
|
|
|
|
package appeng.container.slot;
|
|
|
|
import java.util.List;
|
|
|
|
import com.google.common.collect.ImmutableList;
|
|
|
|
import net.fabricmc.fabric.api.registry.FuelRegistry;
|
|
import net.minecraft.entity.player.PlayerEntity;
|
|
import net.minecraft.entity.player.PlayerInventory;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.item.Items;
|
|
import net.minecraft.screen.slot.Slot;
|
|
import net.minecraft.tag.ItemTags;
|
|
import net.minecraft.tag.Tag;
|
|
import net.minecraft.util.Identifier;
|
|
import net.minecraft.world.World;
|
|
|
|
import alexiil.mc.lib.attributes.item.FixedItemInv;
|
|
|
|
import appeng.api.crafting.ICraftingHelper;
|
|
import appeng.api.definitions.IDefinitions;
|
|
import appeng.api.definitions.IItems;
|
|
import appeng.api.definitions.IMaterials;
|
|
import appeng.api.features.INetworkEncodable;
|
|
import appeng.api.implementations.items.IBiometricCard;
|
|
import appeng.api.implementations.items.ISpatialStorageCell;
|
|
import appeng.api.implementations.items.IStorageComponent;
|
|
import appeng.api.implementations.items.IUpgradeModule;
|
|
import appeng.api.networking.crafting.ICraftingPatternDetails;
|
|
import appeng.api.storage.cells.ICellWorkbenchItem;
|
|
import appeng.core.Api;
|
|
import appeng.items.misc.EncodedPatternItem;
|
|
import appeng.recipes.handlers.GrinderRecipes;
|
|
import appeng.tile.misc.InscriberRecipes;
|
|
import appeng.util.Platform;
|
|
|
|
/**
|
|
* @author AlgorithmX2
|
|
* @author thatsIch
|
|
* @version rv2
|
|
* @since rv0
|
|
*/
|
|
public class RestrictedInputSlot extends AppEngSlot {
|
|
|
|
private static final List<Identifier> METAL_INGOT_TAGS = ImmutableList.of(new Identifier("c:copper_ingots"),
|
|
new Identifier("c:tin_ingots"), new Identifier("c:iron_ingots"), new Identifier("c:gold_ingots"),
|
|
new Identifier("c:lead_ingots"), new Identifier("c:bronze_ingots"), new Identifier("c:brass_ingots"),
|
|
new Identifier("c:nickel_ingots"), new Identifier("c:aluminium_ingots"));
|
|
|
|
private final PlacableItemType which;
|
|
private final PlayerInventory p;
|
|
private boolean allowEdit = true;
|
|
private int stackLimit = -1;
|
|
|
|
public RestrictedInputSlot(final PlacableItemType valid, final FixedItemInv inv, final int invSlot, final int x,
|
|
final int y, final PlayerInventory p) {
|
|
super(inv, invSlot, x, y);
|
|
this.which = valid;
|
|
this.setIIcon(valid.IIcon);
|
|
this.p = p;
|
|
}
|
|
|
|
@Override
|
|
public int getMaxItemCount() {
|
|
if (this.stackLimit != -1) {
|
|
return this.stackLimit;
|
|
}
|
|
return super.getMaxItemCount();
|
|
}
|
|
|
|
public boolean isValid(final ItemStack is, final World theWorld) {
|
|
if (this.which == PlacableItemType.VALID_ENCODED_PATTERN_W_OUTPUT) {
|
|
return Api.instance().crafting().decodePattern(is, theWorld) != null;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public Slot setStackLimit(final int i) {
|
|
this.stackLimit = i;
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public boolean canInsert(final ItemStack stack) {
|
|
if (!this.getContainer().isValidForSlot(this, stack)) {
|
|
return false;
|
|
}
|
|
|
|
if (stack.isEmpty()) {
|
|
return false;
|
|
}
|
|
|
|
if (stack.getItem() == Items.AIR) {
|
|
return false;
|
|
}
|
|
|
|
if (!super.canInsert(stack)) {
|
|
return false;
|
|
}
|
|
|
|
if (!this.isAllowEdit()) {
|
|
return false;
|
|
}
|
|
|
|
final IDefinitions definitions = Api.instance().definitions();
|
|
final IMaterials materials = definitions.materials();
|
|
final IItems items = definitions.items();
|
|
final ICraftingHelper crafting = Api.instance().crafting();
|
|
|
|
switch (this.which) {
|
|
case ENCODED_CRAFTING_PATTERN:
|
|
final ICraftingPatternDetails de = crafting.decodePattern(stack, this.p.player.world);
|
|
if (de != null) {
|
|
return de.isCraftable();
|
|
}
|
|
return false;
|
|
case VALID_ENCODED_PATTERN_W_OUTPUT:
|
|
case ENCODED_PATTERN_W_OUTPUT:
|
|
case ENCODED_PATTERN:
|
|
return crafting.isEncodedPattern(stack);
|
|
case BLANK_PATTERN:
|
|
return materials.blankPattern().isSameAs(stack);
|
|
|
|
case PATTERN:
|
|
return materials.blankPattern().isSameAs(stack) || crafting.isEncodedPattern(stack);
|
|
|
|
case INSCRIBER_PLATE:
|
|
if (materials.namePress().isSameAs(stack)) {
|
|
return true;
|
|
}
|
|
|
|
return InscriberRecipes.isValidOptionalIngredient(p.player.world, stack);
|
|
|
|
case INSCRIBER_INPUT:
|
|
return true;/*
|
|
* for (ItemStack is : Inscribe.inputs) if ( Platform.isSameItemPrecise( is, i )
|
|
* ) return true; return false;
|
|
*/
|
|
|
|
case METAL_INGOTS:
|
|
|
|
return isMetalIngot(stack);
|
|
|
|
case VIEW_CELL:
|
|
return items.viewCell().isSameAs(stack);
|
|
case ORE:
|
|
return GrinderRecipes.isValidIngredient(p.player.world, stack);
|
|
case FUEL:
|
|
return FuelRegistry.INSTANCE.get(stack.getItem()) != null;
|
|
case POWERED_TOOL:
|
|
return Platform.isChargeable(stack);
|
|
case QE_SINGULARITY:
|
|
return materials.qESingularity().isSameAs(stack);
|
|
|
|
case RANGE_BOOSTER:
|
|
return materials.wirelessBooster().isSameAs(stack);
|
|
|
|
case SPATIAL_STORAGE_CELLS:
|
|
return stack.getItem() instanceof ISpatialStorageCell
|
|
&& ((ISpatialStorageCell) stack.getItem()).isSpatialStorage(stack);
|
|
case STORAGE_CELLS:
|
|
return Api.instance().registries().cell().isCellHandled(stack);
|
|
case WORKBENCH_CELL:
|
|
return stack.getItem() instanceof ICellWorkbenchItem
|
|
&& ((ICellWorkbenchItem) stack.getItem()).isEditable(stack);
|
|
case STORAGE_COMPONENT:
|
|
return stack.getItem() instanceof IStorageComponent
|
|
&& ((IStorageComponent) stack.getItem()).isStorageComponent(stack);
|
|
case TRASH:
|
|
if (Api.instance().registries().cell().isCellHandled(stack)) {
|
|
return false;
|
|
}
|
|
|
|
return !(stack.getItem() instanceof IStorageComponent
|
|
&& ((IStorageComponent) stack.getItem()).isStorageComponent(stack));
|
|
case ENCODABLE_ITEM:
|
|
return stack.getItem() instanceof INetworkEncodable
|
|
|| Api.instance().registries().wireless().isWirelessTerminal(stack);
|
|
case BIOMETRIC_CARD:
|
|
return stack.getItem() instanceof IBiometricCard;
|
|
case UPGRADES:
|
|
return stack.getItem() instanceof IUpgradeModule
|
|
&& ((IUpgradeModule) stack.getItem()).getType(stack) != null;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean canTakeItems(final PlayerEntity player) {
|
|
return this.isAllowEdit();
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getDisplayStack() {
|
|
if (Platform.isClient() && (this.which == PlacableItemType.ENCODED_PATTERN)) {
|
|
final ItemStack is = super.getStack();
|
|
if (!is.isEmpty() && is.getItem() instanceof EncodedPatternItem) {
|
|
final EncodedPatternItem iep = (EncodedPatternItem) is.getItem();
|
|
final ItemStack out = iep.getOutput(p.player.world, is);
|
|
if (!out.isEmpty()) {
|
|
return out;
|
|
}
|
|
}
|
|
}
|
|
return super.getStack();
|
|
}
|
|
|
|
public static boolean isMetalIngot(final ItemStack i) {
|
|
if (Platform.itemComparisons().isSameItem(i, new ItemStack(Items.IRON_INGOT))) {
|
|
return true;
|
|
}
|
|
|
|
// TODO: Can be optimized by somehow caching the Tag's
|
|
Item item = i.getItem();
|
|
for (Identifier tagName : METAL_INGOT_TAGS) {
|
|
Tag<Item> ingotTag = ItemTags.getTagGroup().getTag(tagName);
|
|
if (ingotTag != null && item.isIn(ingotTag)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private boolean isAllowEdit() {
|
|
return this.allowEdit;
|
|
}
|
|
|
|
public void setAllowEdit(final boolean allowEdit) {
|
|
this.allowEdit = allowEdit;
|
|
}
|
|
|
|
public enum PlacableItemType {
|
|
STORAGE_CELLS(15), ORE(16 + 15), STORAGE_COMPONENT(3 * 16 + 15),
|
|
|
|
ENCODABLE_ITEM(4 * 16 + 15), TRASH(5 * 16 + 15), VALID_ENCODED_PATTERN_W_OUTPUT(7 * 16 + 15),
|
|
ENCODED_PATTERN_W_OUTPUT(7 * 16 + 15),
|
|
|
|
ENCODED_CRAFTING_PATTERN(7 * 16 + 15), ENCODED_PATTERN(7 * 16 + 15), PATTERN(8 * 16 + 15),
|
|
BLANK_PATTERN(8 * 16 + 15), POWERED_TOOL(9 * 16 + 15),
|
|
|
|
RANGE_BOOSTER(6 * 16 + 15), QE_SINGULARITY(10 * 16 + 15), SPATIAL_STORAGE_CELLS(11 * 16 + 15),
|
|
|
|
FUEL(12 * 16 + 15), UPGRADES(13 * 16 + 15), WORKBENCH_CELL(15), BIOMETRIC_CARD(14 * 16 + 15),
|
|
VIEW_CELL(4 * 16 + 14),
|
|
|
|
INSCRIBER_PLATE(2 * 16 + 14), INSCRIBER_INPUT(3 * 16 + 14), METAL_INGOTS(3 * 16 + 14);
|
|
|
|
public final int IIcon;
|
|
|
|
PlacableItemType(final int o) {
|
|
this.IIcon = o;
|
|
}
|
|
}
|
|
}
|