diff --git a/src/main/java/forestry/apiculture/items/ItemBeealyzer.java b/src/main/java/forestry/apiculture/items/ItemBeealyzer.java index 98f37bbc3..9dab61450 100644 --- a/src/main/java/forestry/apiculture/items/ItemBeealyzer.java +++ b/src/main/java/forestry/apiculture/items/ItemBeealyzer.java @@ -26,13 +26,11 @@ public class ItemBeealyzer extends ItemWithGui { @Override public Object getGui(EntityPlayer player, ItemStack heldItem, int data) { - ItemInventoryBeealyzer inventory = new ItemInventoryBeealyzer(player, heldItem); - return new GuiBeealyzer(player, inventory); + return new GuiBeealyzer(player, new ItemInventoryBeealyzer(player, heldItem)); } @Override public Object getContainer(EntityPlayer player, ItemStack heldItem, int data) { - ItemInventoryBeealyzer inventory = new ItemInventoryBeealyzer(player, heldItem); - return new ContainerAlyzer(inventory, player); + return new ContainerAlyzer(new ItemInventoryBeealyzer(player, heldItem), player); } } diff --git a/src/main/java/forestry/apiculture/multiblock/TileAlvearySwarmer.java b/src/main/java/forestry/apiculture/multiblock/TileAlvearySwarmer.java index 65feb09f0..32e1b7a8f 100644 --- a/src/main/java/forestry/apiculture/multiblock/TileAlvearySwarmer.java +++ b/src/main/java/forestry/apiculture/multiblock/TileAlvearySwarmer.java @@ -32,8 +32,8 @@ import forestry.apiculture.worldgen.Hive; import forestry.apiculture.worldgen.HiveDecorator; import forestry.apiculture.worldgen.HiveDescriptionSwarmer; import forestry.core.inventory.IInventoryAdapter; -import forestry.core.inventory.wrappers.IInvSlot; -import forestry.core.inventory.wrappers.InventoryIterator; +import forestry.core.inventory.iterators.IExtInvSlot; +import forestry.core.inventory.iterators.InventoryIterator; import forestry.core.proxy.Proxies; import forestry.core.tiles.IActivatable; import forestry.core.utils.ItemStackUtil; @@ -116,7 +116,7 @@ public class TileAlvearySwarmer extends TileAlveary implements ISidedInventory, return 0; } - for (IInvSlot slot : InventoryIterator.getIterable(getInternalInventory())) { + for (IExtInvSlot slot : InventoryIterator.getIterable(getInternalInventory())) { ItemStack stack = slot.getStackInSlot(); for (Entry entry : BeeManager.inducers.entrySet()) { if (ItemStackUtil.isIdenticalItem(entry.getKey(), stack)) { diff --git a/src/main/java/forestry/core/inventory/InventoryObject.java b/src/main/java/forestry/core/inventory/InventoryObject.java new file mode 100644 index 000000000..153ccf7ec --- /dev/null +++ b/src/main/java/forestry/core/inventory/InventoryObject.java @@ -0,0 +1,35 @@ +/****************************************************************************** + * Copyright (c) CovertJaguar, 2011-2016 * + * http://railcraft.info * + * * + * This code is the property of CovertJaguar * + * and may only be used with explicit written * + * permission unless otherwise specified on the * + * license page at http://railcraft.info/wiki/info:license. * + ******************************************************************************/ + +package forestry.core.inventory; + +import net.minecraft.inventory.IInventory; +import net.minecraftforge.items.IItemHandler; + +/** + * Created by CovertJaguar on 3/15/2016 for Railcraft. + * + * @author CovertJaguar + */ +public class InventoryObject { + private Object inventory; + + public InventoryObject(IInventory inventory) { + this.inventory = inventory; + } + + public InventoryObject(IItemHandler inventory) { + this.inventory = inventory; + } + + public Object getObject() { + return inventory; + } +} diff --git a/src/main/java/forestry/core/inventory/InventoryPlain.java b/src/main/java/forestry/core/inventory/InventoryPlain.java index e979931c3..90322f1ed 100644 --- a/src/main/java/forestry/core/inventory/InventoryPlain.java +++ b/src/main/java/forestry/core/inventory/InventoryPlain.java @@ -27,6 +27,11 @@ public class InventoryPlain implements IInventory, INbtWritable, INbtReadable { private final String name; private final int stackLimit; + public InventoryPlain(int size) { + this(size, null, 64); + } + + public InventoryPlain(int size, String name) { this(size, name, 64); } @@ -82,6 +87,9 @@ public class InventoryPlain implements IInventory, INbtWritable, INbtReadable { @Override public String getName() { + if(name == null){ + return "Plain"; + } return name; } @@ -106,7 +114,7 @@ public class InventoryPlain implements IInventory, INbtWritable, INbtReadable { @Override public boolean hasCustomName() { - return true; + return name != null; } @Override diff --git a/src/main/java/forestry/greenhouse/models/ModelGreenhouseSprinkler.java b/src/main/java/forestry/core/inventory/ItemHandlerItemInventory.java similarity index 62% rename from src/main/java/forestry/greenhouse/models/ModelGreenhouseSprinkler.java rename to src/main/java/forestry/core/inventory/ItemHandlerItemInventory.java index d04c5affc..d1f563ade 100644 --- a/src/main/java/forestry/greenhouse/models/ModelGreenhouseSprinkler.java +++ b/src/main/java/forestry/core/inventory/ItemHandlerItemInventory.java @@ -8,8 +8,22 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.greenhouse.models; +package forestry.core.inventory; -public class ModelGreenhouseSprinkler { +import net.minecraftforge.items.wrapper.InvWrapper; +public class ItemHandlerItemInventory extends InvWrapper { + + private I itemInventory; + + public ItemHandlerItemInventory(I inv) { + super(inv); + + itemInventory = inv; + } + + public I getItemInventory() { + return itemInventory; + } + } diff --git a/src/main/java/forestry/core/inventory/ItemInventory.java b/src/main/java/forestry/core/inventory/ItemInventory.java index bd6261bec..386389d63 100755 --- a/src/main/java/forestry/core/inventory/ItemInventory.java +++ b/src/main/java/forestry/core/inventory/ItemInventory.java @@ -17,10 +17,15 @@ import net.minecraft.inventory.IInventory; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.ChatComponentText; +import net.minecraft.util.EnumFacing; import net.minecraft.util.IChatComponent; +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.common.capabilities.ICapabilityProvider; +import net.minecraftforge.items.CapabilityItemHandler; +import net.minecraftforge.items.IItemHandler; import forestry.core.tiles.IFilterSlotDelegate; -public abstract class ItemInventory implements IInventory, IFilterSlotDelegate { +public abstract class ItemInventory implements IInventory, IFilterSlotDelegate, ICapabilityProvider { private static final String KEY_SLOTS = "Slots"; private static final String KEY_UID = "UID"; private static final Random rand = new Random(); @@ -286,4 +291,19 @@ public abstract class ItemInventory implements IInventory, IFilterSlotDelegate { @Override public void setField(int id, int value) { } + + IItemHandler handler = new ItemHandlerItemInventory(this); + + @Override + public T getCapability(Capability capability, EnumFacing facing) { + if(capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY){ + return (T) handler; + } + return null; + } + + @Override + public boolean hasCapability(Capability capability, EnumFacing facing) { + return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY; + } } diff --git a/src/main/java/forestry/core/inventory/filters/ArrayStackFilter.java b/src/main/java/forestry/core/inventory/filters/ArrayStackFilter.java index c218fb093..257567f76 100755 --- a/src/main/java/forestry/core/inventory/filters/ArrayStackFilter.java +++ b/src/main/java/forestry/core/inventory/filters/ArrayStackFilter.java @@ -17,32 +17,32 @@ import forestry.core.utils.InventoryUtil; /** * @author CovertJaguar */ -public class ArrayStackFilter implements IStackFilter { +public class ArrayStackFilter extends StackFilter { - private final ItemStack[] stacks; + private final ItemStack[] stacks; - public ArrayStackFilter(ItemStack... stacks) { - this.stacks = stacks; - } + public ArrayStackFilter(ItemStack... stacks) { + this.stacks = stacks; + } - @Override - public boolean matches(ItemStack stack) { - if (stacks.length == 0 || !hasFilter()) { - return true; - } - return InventoryUtil.isItemEqual(stack, stacks); - } + @Override + public boolean apply(final ItemStack stack) { + if (stacks.length == 0 || !hasFilter()) { + return true; + } + return InventoryUtil.isItemEqual(stack, stacks); + } - public ItemStack[] getStacks() { - return stacks; - } + public ItemStack[] getStacks() { + return stacks; + } - private boolean hasFilter() { - for (ItemStack filter : stacks) { - if (filter != null) { - return true; - } - } - return false; - } + public boolean hasFilter() { + for (ItemStack filter : stacks) { + if (filter != null) { + return true; + } + } + return false; + } } diff --git a/src/main/java/forestry/core/inventory/filters/InvertedStackFilter.java b/src/main/java/forestry/core/inventory/filters/ExclusionStackFilter.java old mode 100755 new mode 100644 similarity index 65% rename from src/main/java/forestry/core/inventory/filters/InvertedStackFilter.java rename to src/main/java/forestry/core/inventory/filters/ExclusionStackFilter.java index fc041f978..f2640ebf5 --- a/src/main/java/forestry/core/inventory/filters/InvertedStackFilter.java +++ b/src/main/java/forestry/core/inventory/filters/ExclusionStackFilter.java @@ -10,24 +10,26 @@ ******************************************************************************/ package forestry.core.inventory.filters; +import forestry.core.utils.InventoryUtil; import net.minecraft.item.ItemStack; /** * @author CovertJaguar */ -public class InvertedStackFilter implements IStackFilter { +public class ExclusionStackFilter extends StackFilter { - private final IStackFilter filter; + private final ItemStack[] exclude; - public InvertedStackFilter(IStackFilter filter) { - this.filter = filter; - } + public ExclusionStackFilter(ItemStack... exclude) { + this.exclude = exclude; + } - @Override - public boolean matches(ItemStack stack) { - if (stack == null) { + @Override + public boolean apply(final ItemStack stack) { + if (stack == null) { return false; } - return !filter.matches(stack); - } + return !InventoryUtil.isItemEqual(stack, exclude); + } + } diff --git a/src/main/java/forestry/core/inventory/filters/IStackFilter.java b/src/main/java/forestry/core/inventory/filters/IStackFilter.java index 82ddf56f1..94e2d127b 100755 --- a/src/main/java/forestry/core/inventory/filters/IStackFilter.java +++ b/src/main/java/forestry/core/inventory/filters/IStackFilter.java @@ -10,16 +10,21 @@ ******************************************************************************/ package forestry.core.inventory.filters; +import com.google.common.base.Predicate; import net.minecraft.item.ItemStack; +import javax.annotation.Nonnull; + /** - * This interface is used with several of the functions in IItemTransfer to - * provide a convenient means of dealing with entire classes of items without - * having to specify each item individually. + * This interface is used to provide a convenient means of dealing with entire classes of items without having to specify each item individually. * * @author CovertJaguar */ -public interface IStackFilter { +public interface IStackFilter extends Predicate { - boolean matches(ItemStack stack); + StackFilter and(@Nonnull Predicate... other); + + StackFilter or(@Nonnull Predicate... other); + + StackFilter negate(); } diff --git a/src/main/java/forestry/core/inventory/filters/InventoryStackFilter.java b/src/main/java/forestry/core/inventory/filters/InventoryStackFilter.java new file mode 100644 index 000000000..49fe5564f --- /dev/null +++ b/src/main/java/forestry/core/inventory/filters/InventoryStackFilter.java @@ -0,0 +1,32 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.core.inventory.filters; + +import forestry.core.utils.InventoryUtil; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; + +/** + * @author CovertJaguar + */ +public class InventoryStackFilter extends StackFilter { + + private final IInventory inv; + + public InventoryStackFilter(IInventory inv) { + this.inv = inv; + } + + @Override + public boolean apply(final ItemStack stack) { + return InventoryUtil.containsItem(inv, stack); + } +} diff --git a/src/main/java/forestry/core/inventory/filters/StackFilter.java b/src/main/java/forestry/core/inventory/filters/StackFilter.java index aadb69932..6adeb12cb 100755 --- a/src/main/java/forestry/core/inventory/filters/StackFilter.java +++ b/src/main/java/forestry/core/inventory/filters/StackFilter.java @@ -10,40 +10,113 @@ ******************************************************************************/ package forestry.core.inventory.filters; -import net.minecraft.init.Items; -import net.minecraft.item.ItemFood; -import net.minecraft.item.ItemSeeds; +import com.google.common.base.Predicate; import net.minecraft.item.ItemStack; -import net.minecraft.tileentity.TileEntityFurnace; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; /** - * This interface is used with several of the functions in IItemTransfer to - * provide a convenient means of dealing with entire classes of items without - * having to specify each item individually. + * This class is used to provide a convenient means of dealing with entire classes of items without having to specify each item individually. * * @author CovertJaguar */ -public enum StackFilter implements IStackFilter { +@SuppressWarnings("unused") +public class StackFilter implements IStackFilter { + /** + * Railcraft adds the following IItemTypes during preInit: ALL, FUEL, TRACK, MINECART, BALLAST, FEED + *

+ * Feel free to grab them from here or define your own. + */ + public static final Map standardFilters = new HashMap(); - ALL { - @Override - public boolean matches(ItemStack stack) { - return true; - } - }, - FUEL { - @Override - public boolean matches(ItemStack stack) { - return TileEntityFurnace.getItemBurnTime(stack) > 0; - } - }, - FEED { - @Override - public boolean matches(ItemStack stack) { - return stack.getItem() instanceof ItemFood || stack.getItem() == Items.wheat || stack.getItem() instanceof ItemSeeds; - } - }; + @Override + public boolean apply(@Nullable final ItemStack input) { + return true; + } + + @Override + public final StackFilter and(@Nonnull final Predicate... other) { + Objects.requireNonNull(other); + return new StackFilter() { + @Override + public boolean apply(ItemStack stack) { + for (Predicate filter : other) { + if (!filter.apply(stack)) { + return false; + } + } + return StackFilter.this.apply(stack); + } + }; + } + + @Override + public final StackFilter or(@Nonnull final Predicate... other) { + Objects.requireNonNull(other); + return new StackFilter() { + @Override + public boolean apply(ItemStack stack) { + for (Predicate filter : other) { + if (filter.apply(stack)) { + return true; + } + } + return StackFilter.this.apply(stack); + } + }; + } + + @Override + public final StackFilter negate() { + return new StackFilter() { + @Override + public boolean apply(ItemStack stack) { + return !StackFilter.this.apply(stack); + } + }; + } + + private static StackFilter buildAnd(@Nonnull final Predicate... filters) { + return new StackFilter() { + @Override + public boolean apply(ItemStack stack) { + Objects.requireNonNull(stack); + for (Predicate filter : filters) { + if (!filter.apply(stack)) { + return false; + } + } + return true; + } + }; + } + + private static StackFilter buildOr(@Nonnull final Predicate... filters) { + return new StackFilter() { + @Override + public boolean apply(ItemStack stack) { + Objects.requireNonNull(stack); + for (Predicate filter : filters) { + if (filter.apply(stack)) { + return true; + } + } + return false; + } + }; + } + + private static StackFilter invert(@Nonnull final Predicate filter) { + return new StackFilter() { + @Override + public boolean apply(ItemStack stack) { + return !filter.apply(stack); + } + }; + } - @Override - public abstract boolean matches(ItemStack stack); } diff --git a/src/main/java/forestry/core/inventory/filters/StandardStackFilters.java b/src/main/java/forestry/core/inventory/filters/StandardStackFilters.java new file mode 100644 index 000000000..8044d53e8 --- /dev/null +++ b/src/main/java/forestry/core/inventory/filters/StandardStackFilters.java @@ -0,0 +1,100 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.core.inventory.filters; + +import com.google.common.base.Predicate; +import net.minecraft.init.Items; +import net.minecraft.item.*; +import net.minecraft.tileentity.TileEntityFurnace; + +import javax.annotation.Nonnull; +import java.util.Objects; + +/** + * This interface is used with several of the functions in IItemTransfer to + * provide a convenient means of dealing with entire classes of items without + * having to specify each item individually. + * + * @author CovertJaguar + */ +public enum StandardStackFilters implements IStackFilter { + + ALL { + @Override + public boolean apply(ItemStack stack) { + return true; + } + }, + FUEL { + @Override + public boolean apply(ItemStack stack) { + return TileEntityFurnace.getItemBurnTime(stack) > 0; + } + }, + FEED { + @Override + public boolean apply(ItemStack stack) { + return stack.getItem() instanceof ItemFood || stack.getItem() == Items.wheat || stack.getItem() instanceof ItemSeeds; + } + }; + + public static void initialize() { + for (StandardStackFilters type : StandardStackFilters.values()) { + StackFilter.standardFilters.put(type.name(), type); + } + } + + @Override + public abstract boolean apply(ItemStack stack); + + @Override + public final StackFilter and(@Nonnull final Predicate... other) { + Objects.requireNonNull(other); + return new StackFilter() { + @Override + public boolean apply(ItemStack stack) { + for (Predicate filter : other) { + if (!filter.apply(stack)) { + return false; + } + } + return StandardStackFilters.this.apply(stack); + } + }; + } + + @Override + public final StackFilter or(@Nonnull final Predicate... other) { + Objects.requireNonNull(other); + return new StackFilter() { + @Override + public boolean apply(ItemStack stack) { + for (Predicate filter : other) { + if (filter.apply(stack)) { + return true; + } + } + return StandardStackFilters.this.apply(stack); + } + }; + } + + @Override + public final StackFilter negate() { + return new StackFilter() { + @Override + public boolean apply(ItemStack stack) { + return !StandardStackFilters.this.apply(stack); + } + }; + } + +} diff --git a/src/main/java/forestry/core/inventory/iterators/IExtInvSlot.java b/src/main/java/forestry/core/inventory/iterators/IExtInvSlot.java new file mode 100644 index 000000000..7890fc96c --- /dev/null +++ b/src/main/java/forestry/core/inventory/iterators/IExtInvSlot.java @@ -0,0 +1,30 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ + +package forestry.core.inventory.iterators; + +import net.minecraft.item.ItemStack; + +/** + * This interface extends IInvSlot by allowing you to modify a slot directly. + * This is only valid on inventories backed by IInventory. + *

+ *

+ * Created by CovertJaguar on 3/16/2016 for Railcraft. + * + * @author CovertJaguar + */ +public interface IExtInvSlot extends IInvSlot { + /** + * Sets the current ItemStack in the slot. + */ + void setStackInSlot(ItemStack stack); +} diff --git a/src/main/java/forestry/core/inventory/wrappers/IInvSlot.java b/src/main/java/forestry/core/inventory/iterators/IInvSlot.java old mode 100755 new mode 100644 similarity index 59% rename from src/main/java/forestry/core/inventory/wrappers/IInvSlot.java rename to src/main/java/forestry/core/inventory/iterators/IInvSlot.java index 895c67b35..c5453e3b6 --- a/src/main/java/forestry/core/inventory/wrappers/IInvSlot.java +++ b/src/main/java/forestry/core/inventory/iterators/IInvSlot.java @@ -8,25 +8,30 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.core.inventory.wrappers; +package forestry.core.inventory.iterators; import net.minecraft.item.ItemStack; /** + * This Interface represents an abstract inventory slot. It provides a unified interface for interfacing with Inventories. + * * @author CovertJaguar */ public interface IInvSlot { - boolean canPutStackInSlot(ItemStack stack); + boolean canPutStackInSlot(ItemStack stack); - boolean canTakeStackFromSlot(ItemStack stack); + boolean canTakeStackFromSlot(ItemStack stack); - ItemStack decreaseStackInSlot(); + ItemStack decreaseStackInSlot(); - ItemStack getStackInSlot(); + /** + * It is not legal to edit the stack returned from this function. + */ + ItemStack getStackInSlot(); - void setStackInSlot(ItemStack stack); +// void setStackInSlot(ItemStack stack); - int getIndex(); + int getIndex(); } diff --git a/src/main/java/forestry/core/inventory/iterators/InventoryIterator.java b/src/main/java/forestry/core/inventory/iterators/InventoryIterator.java new file mode 100644 index 000000000..16afbd2eb --- /dev/null +++ b/src/main/java/forestry/core/inventory/iterators/InventoryIterator.java @@ -0,0 +1,60 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.core.inventory.iterators; + +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.ISidedInventory; +import net.minecraftforge.items.IItemHandler; + +import java.util.ArrayList; +import java.util.List; + +import forestry.core.inventory.InventoryObject; + +/** + * @author CovertJaguar + */ +public abstract class InventoryIterator implements Iterable { + + public static InventoryIterator getIterable(IInventory inv) { + if (inv instanceof ISidedInventory) { + return new SidedInventoryIterator((ISidedInventory) inv); + } + return new StandardInventoryIterator(inv); + } + + public static InventoryIterator getIterable(IItemHandler inv) { + return new ItemHandlerInventoryIterator(inv); + } + + public static InventoryIterator getIterable(InventoryObject inv) { + if (inv.getObject() instanceof ISidedInventory) { + return new SidedInventoryIterator((ISidedInventory) inv.getObject()); + } + if (inv.getObject() instanceof IInventory) { + return new StandardInventoryIterator((IInventory) inv.getObject()); + } + if (inv.getObject() instanceof IItemHandler) { + return new ItemHandlerInventoryIterator((IItemHandler) inv.getObject()); + } + throw new RuntimeException("Invalid Inventory Object"); + } + + public Iterable notNull() { + List filledSlots = new ArrayList(32); + for (T slot : this) { + if (slot.getStackInSlot() != null) { + filledSlots.add(slot); + } + } + return filledSlots; + } +} diff --git a/src/main/java/forestry/core/inventory/iterators/ItemHandlerInventoryIterator.java b/src/main/java/forestry/core/inventory/iterators/ItemHandlerInventoryIterator.java new file mode 100644 index 000000000..54a37d725 --- /dev/null +++ b/src/main/java/forestry/core/inventory/iterators/ItemHandlerInventoryIterator.java @@ -0,0 +1,88 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.core.inventory.iterators; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.items.IItemHandler; + +import java.util.Iterator; + +import forestry.core.utils.InventoryUtil; + +/** + * @author CovertJaguar + */ +public class ItemHandlerInventoryIterator extends InventoryIterator { + + private final IItemHandler inv; + + protected ItemHandlerInventoryIterator(IItemHandler inv) { + this.inv = inv; + } + + @Override + public Iterator iterator() { + return new Iterator() { + int slot = 0; + + @Override + public boolean hasNext() { + return slot < inv.getSlots(); + } + + @Override + public IInvSlot next() { + return new InvSlot(slot++); + } + + @Override + public void remove() { + throw new UnsupportedOperationException("Remove not supported."); + } + + }; + } + + private class InvSlot implements IInvSlot { + + protected final int slot; + + public InvSlot(int slot) { + this.slot = slot; + } + + @Override + public int getIndex() { + return slot; + } + + @Override + public boolean canPutStackInSlot(ItemStack stack) { + return inv.insertItem(slot, stack, true) == null; + } + + @Override + public boolean canTakeStackFromSlot(ItemStack stack) { + return inv.extractItem(slot, 1, true) != null; + } + + @Override + public ItemStack decreaseStackInSlot() { + return inv.extractItem(slot, 1, true); + } + + @Override + public ItemStack getStackInSlot() { + return InventoryUtil.makeSafe(inv.getStackInSlot(slot)); + } + + } +} diff --git a/src/main/java/forestry/core/inventory/iterators/SidedInventoryIterator.java b/src/main/java/forestry/core/inventory/iterators/SidedInventoryIterator.java new file mode 100644 index 000000000..8b2d0f6d6 --- /dev/null +++ b/src/main/java/forestry/core/inventory/iterators/SidedInventoryIterator.java @@ -0,0 +1,72 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.core.inventory.iterators; + +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumFacing; + +import java.util.Iterator; + +/** + * @author CovertJaguar + */ +public class SidedInventoryIterator extends StandardInventoryIterator { + + private final ISidedInventory inv; + + protected SidedInventoryIterator(ISidedInventory inv) { + super(inv); + this.inv = inv; + } + + @Override + public Iterator iterator() { + return new Iterator() { + int[] slots = inv.getSlotsForFace(EnumFacing.DOWN); + int index = 0; + + @Override + public boolean hasNext() { + return slots != null && index < slots.length; + } + + @Override + public IExtInvSlot next() { + return new InvSlot(slots[index++]); + } + + @Override + public void remove() { + throw new UnsupportedOperationException("Remove not supported."); + } + + }; + } + + private class InvSlot extends StandardInventoryIterator.InvSlot implements IExtInvSlot { + + public InvSlot(int slot) { + super(slot); + } + + @Override + public boolean canPutStackInSlot(ItemStack stack) { + return inv.canInsertItem(slot, stack, EnumFacing.DOWN); + } + + @Override + public boolean canTakeStackFromSlot(ItemStack stack) { + return inv.canExtractItem(slot, stack, EnumFacing.DOWN); + } + + } +} diff --git a/src/main/java/forestry/core/inventory/iterators/StandardInventoryIterator.java b/src/main/java/forestry/core/inventory/iterators/StandardInventoryIterator.java new file mode 100644 index 000000000..50727aee3 --- /dev/null +++ b/src/main/java/forestry/core/inventory/iterators/StandardInventoryIterator.java @@ -0,0 +1,100 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ + +package forestry.core.inventory.iterators; + +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; + +import java.util.Iterator; + +/** + * @author CovertJaguar + */ +public class StandardInventoryIterator extends InventoryIterator { + + private final IInventory inv; + private final int invSize; + + protected StandardInventoryIterator(IInventory inv) { + this.inv = inv; + this.invSize = inv.getSizeInventory(); + } + + @Override + public Iterator iterator() { + return new Iterator() { + int slot = 0; + + @Override + public boolean hasNext() { + return slot < invSize; + } + + @Override + public IExtInvSlot next() { + return new InvSlot(slot++); + } + + @Override + public void remove() { + throw new UnsupportedOperationException("Remove not supported."); + } + + }; + } + + class InvSlot implements IExtInvSlot { + + protected final int slot; + + public InvSlot(int slot) { + this.slot = slot; + } + + @Override + public ItemStack getStackInSlot() { + return inv.getStackInSlot(slot); + } + + @Override + public void setStackInSlot(ItemStack stack) { + inv.setInventorySlotContents(slot, stack); + } + + @Override + public boolean canPutStackInSlot(ItemStack stack) { + return inv.isItemValidForSlot(slot, stack); + } + + @Override + public boolean canTakeStackFromSlot(ItemStack stack) { + return true; + } + + @Override + public ItemStack decreaseStackInSlot() { + return inv.decrStackSize(slot, 1); + } + + @Override + public int getIndex() { + return slot; + } + + @Override + public String toString() { + ItemStack stack = getStackInSlot(); + return "SlotNum = " + slot + " Stack = " + (stack == null ? "null" : getStackInSlot().toString()); + } + + } +} diff --git a/src/main/java/forestry/core/inventory/manipulators/InventoryManipulator.java b/src/main/java/forestry/core/inventory/manipulators/InventoryManipulator.java index e01eedb5f..e3c55ef28 100755 --- a/src/main/java/forestry/core/inventory/manipulators/InventoryManipulator.java +++ b/src/main/java/forestry/core/inventory/manipulators/InventoryManipulator.java @@ -10,177 +10,132 @@ ******************************************************************************/ package forestry.core.inventory.manipulators; -import java.util.ArrayList; -import java.util.List; - import net.minecraft.inventory.IInventory; import net.minecraft.item.ItemStack; +import net.minecraftforge.items.IItemHandler; +import java.util.List; + +import forestry.core.inventory.InventoryObject; import forestry.core.inventory.filters.IStackFilter; -import forestry.core.inventory.wrappers.IInvSlot; -import forestry.core.inventory.wrappers.InventoryIterator; -import forestry.core.utils.InventoryUtil; +import forestry.core.inventory.iterators.IExtInvSlot; +import forestry.core.inventory.iterators.IInvSlot; /** * @author CovertJaguar */ -public class InventoryManipulator { +public abstract class InventoryManipulator implements Iterable { - private final IInventory inv; + public static InventoryManipulator get(IInventory inv) { + return new StandardInventoryManipulator(inv); + } - public static InventoryManipulator get(IInventory inv) { - return new InventoryManipulator(inv); - } + public static InventoryManipulator get(IItemHandler inv) { + return new ItemHandlerInventoryManipulator(inv); + } - protected InventoryManipulator(IInventory inv) { - this.inv = inv; - } - - protected Iterable getSlots() { - return InventoryIterator.getIterable(inv); - } - - public boolean canAddStack(ItemStack stack) { - return tryAddStack(stack) == null; - } - - public ItemStack tryAddStack(ItemStack stack) { - return addStack(stack, false); - } - - /** - * Attempt to add the stack to the inventory. - * - * @return The remainder - */ - public ItemStack addStack(ItemStack stack) { - return addStack(stack, true); - } - - private ItemStack addStack(ItemStack stack, boolean doAdd) { - if (stack == null || stack.stackSize <= 0) { - return null; + public static InventoryManipulator get(InventoryObject inv) { + if (inv.getObject() instanceof IInventory) { + return new StandardInventoryManipulator((IInventory) inv.getObject()); } - stack = stack.copy(); - List filledSlots = new ArrayList<>(inv.getSizeInventory()); - List emptySlots = new ArrayList<>(inv.getSizeInventory()); - for (IInvSlot slot : InventoryIterator.getIterable(inv)) { - if (slot.canPutStackInSlot(stack)) { - if (slot.getStackInSlot() == null) { - emptySlots.add(slot); - } else { - filledSlots.add(slot); - } - } + if (inv.getObject() instanceof IItemHandler) { + return new ItemHandlerInventoryManipulator((IItemHandler) inv.getObject()); } + throw new RuntimeException("Invalid Inventory Object"); + } - int injected = 0; - injected = tryPut(filledSlots, stack, injected, doAdd); - injected = tryPut(emptySlots, stack, injected, doAdd); - stack.stackSize -= injected; - if (stack.stackSize <= 0) { - return null; - } - return stack; - } + protected InventoryManipulator() { + } - private int tryPut(List slots, ItemStack stack, int injected, boolean doAdd) { - if (injected >= stack.stackSize) { - return injected; - } - for (IInvSlot slot : slots) { - ItemStack stackInSlot = slot.getStackInSlot(); - if (stackInSlot == null || InventoryUtil.isItemEqual(stackInSlot, stack)) { - int used = addToSlot(slot, stack, stack.stackSize - injected, doAdd); - if (used > 0) { - injected += used; - if (injected >= stack.stackSize) { - return injected; - } - } - } - } - return injected; - } + public boolean canAddStack(ItemStack stack) { + return tryAddStack(stack) == null; + } - /** - * @param available Amount we can move - * @return Return the number of items moved. - */ - private int addToSlot(IInvSlot slot, ItemStack stack, int available, boolean doAdd) { - int max = Math.min(stack.getMaxStackSize(), inv.getInventoryStackLimit()); + public ItemStack tryAddStack(ItemStack stack) { + return addStack(stack, false); + } - ItemStack stackInSlot = slot.getStackInSlot(); - if (stackInSlot == null) { - int wanted = Math.min(available, max); - if (doAdd) { - stackInSlot = stack.copy(); - stackInSlot.stackSize = wanted; - slot.setStackInSlot(stackInSlot); - } - return wanted; - } + /** + * Attempt to add the stack to the inventory. + * + * @return The remainder + */ + public ItemStack addStack(ItemStack stack) { + return addStack(stack, true); + } - if (!InventoryUtil.isItemEqual(stack, stackInSlot)) { - return 0; - } + protected abstract ItemStack addStack(ItemStack stack, boolean doAdd); - int wanted = max - stackInSlot.stackSize; - if (wanted <= 0) { - return 0; - } + /** + * Returns true if an item matching the filter can be removed from the + * inventory. + */ + public boolean canRemoveItem(IStackFilter filter) { + return tryRemoveItem(filter) == null; + } - if (wanted > available) { - wanted = available; - } + /** + * Returns the item that would be returned if an item matching the filter + * was removed. Does not modify the inventory. + */ + public ItemStack tryRemoveItem(IStackFilter filter) { + for (IInvSlot slot : this) { + ItemStack stack = slot.getStackInSlot(); + if (stack != null && stack.stackSize > 0 && slot.canTakeStackFromSlot(stack) && filter.apply(stack)) { + ItemStack output = stack.copy(); + output.stackSize = 1; + return output; + } + } + return null; + } - if (doAdd) { - stackInSlot.stackSize += wanted; - slot.setStackInSlot(stackInSlot); - } - return wanted; - } - - public boolean canRemoveItem(IStackFilter filter) { - return tryRemoveItem(filter) == null; - } - - public ItemStack tryRemoveItem(IStackFilter filter) { - for (IInvSlot slot : getSlots()) { - ItemStack stack = slot.getStackInSlot(); - if (stack != null && slot.canTakeStackFromSlot(stack) && filter.matches(stack)) { - ItemStack output = stack.copy(); - output.stackSize = 1; - return output; - } - } - return null; - } - - public ItemStack removeItem(IStackFilter filter) { - for (IInvSlot slot : getSlots()) { - ItemStack stack = slot.getStackInSlot(); - if (stack != null && slot.canTakeStackFromSlot(stack) && filter.matches(stack)) { + /** + * Removed an item matching the filter. + */ + public ItemStack removeItem(IStackFilter filter) { + for (IInvSlot slot : this) { + ItemStack stack = slot.getStackInSlot(); + if (stack != null && stack.stackSize > 0 && slot.canTakeStackFromSlot(stack) && filter.apply(stack)) { return slot.decreaseStackInSlot(); } - } - return null; - } + } + return null; + } - public ItemStack moveItem(IInventory dest, IStackFilter filter) { - InventoryManipulator imDest = InventoryManipulator.get(dest); - for (IInvSlot slot : getSlots()) { - ItemStack stack = slot.getStackInSlot(); - if (stack != null && slot.canTakeStackFromSlot(stack) && filter.matches(stack)) { - stack = stack.copy(); - stack.stackSize = 1; - stack = imDest.addStack(stack); - if (stack == null) { + public boolean canRemoveItems(IStackFilter filter, int maxAmount) { + List outputList = removeItem(filter, maxAmount, false); + int found = 0; + for (ItemStack stack : outputList) { + found += stack.stackSize; + } + return found == maxAmount; + } + + public List removeItems(IStackFilter filter, int maxAmount) { + return removeItem(filter, maxAmount, true); + } + + protected abstract List removeItem(IStackFilter filter, int maxAmount, boolean doRemove); + + public ItemStack moveItem(IInventory dest, IStackFilter filter) { + return moveItem(new InventoryObject(dest), filter); + } + + public ItemStack moveItem(InventoryObject dest, IStackFilter filter) { + InventoryManipulator imDest = InventoryManipulator.get(dest); + for (IInvSlot slot : this) { + ItemStack stack = slot.getStackInSlot(); + if (stack != null && stack.stackSize > 0 && slot.canTakeStackFromSlot(stack) && filter.apply(stack)) { + stack = stack.copy(); + stack.stackSize = 1; + stack = imDest.addStack(stack); + if (stack == null) { return slot.decreaseStackInSlot(); } - } - } - return null; - } + } + } + return null; + } } diff --git a/src/main/java/forestry/core/inventory/manipulators/ItemHandlerInventoryManipulator.java b/src/main/java/forestry/core/inventory/manipulators/ItemHandlerInventoryManipulator.java new file mode 100644 index 000000000..09813c8c9 --- /dev/null +++ b/src/main/java/forestry/core/inventory/manipulators/ItemHandlerInventoryManipulator.java @@ -0,0 +1,106 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.core.inventory.manipulators; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.items.IItemHandler; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import forestry.core.inventory.filters.IStackFilter; +import forestry.core.inventory.iterators.IInvSlot; +import forestry.core.inventory.iterators.InventoryIterator; + +/** + * @author CovertJaguar + */ +public class ItemHandlerInventoryManipulator extends InventoryManipulator { + + private final IItemHandler inv; + + protected ItemHandlerInventoryManipulator(IItemHandler inv) { + this.inv = inv; + } + + @Override + public Iterator iterator() { + return InventoryIterator.getIterable(inv).iterator(); + } + + @Override + protected ItemStack addStack(ItemStack stack, boolean doAdd) { + if (stack == null || stack.stackSize <= 0) { + return null; + } + stack = stack.copy(); + List filledSlots = new ArrayList(inv.getSlots()); + List emptySlots = new ArrayList(inv.getSlots()); + for (IInvSlot slot : InventoryIterator.getIterable(inv)) { + if (slot.canPutStackInSlot(stack)) { + if (slot.getStackInSlot() == null) { + emptySlots.add(slot); + } else { + filledSlots.add(slot); + } + } + } + + int injected = 0; + injected = tryPut(filledSlots, stack, injected, doAdd); + injected = tryPut(emptySlots, stack, injected, doAdd); + stack.stackSize -= injected; + if (stack.stackSize <= 0) { + return null; + } + return stack; + } + + private int tryPut(List slots, ItemStack stack, int injected, boolean doAdd) { + if (injected >= stack.stackSize) { + return injected; + } + for (IInvSlot slot : slots) { + ItemStack stackToInsert = stack.copy(); + stackToInsert.stackSize = stack.stackSize - injected; + ItemStack remainder = inv.insertItem(slot.getIndex(), stackToInsert, !doAdd); + if (remainder == null) { + return injected; + } + injected += remainder.stackSize; + if (injected >= stack.stackSize) { + return injected; + } + } + return injected; + } + + @Override + protected List removeItem(IStackFilter filter, int maxAmount, boolean doRemove) { + int amountNeeded = maxAmount; + List outputList = new ArrayList(); + for (IInvSlot slot : this) { + if (amountNeeded <= 0) { + break; + } + ItemStack stack = slot.getStackInSlot(); + if (stack != null && stack.stackSize > 0 && slot.canTakeStackFromSlot(stack) && filter.apply(stack)) { + ItemStack removed = inv.extractItem(slot.getIndex(), amountNeeded, !doRemove); + if (removed != null) { + amountNeeded -= removed.stackSize; + outputList.add(removed); + } + } + } + return outputList; + } +} diff --git a/src/main/java/forestry/core/inventory/manipulators/StandardInventoryManipulator.java b/src/main/java/forestry/core/inventory/manipulators/StandardInventoryManipulator.java new file mode 100644 index 000000000..4666ad623 --- /dev/null +++ b/src/main/java/forestry/core/inventory/manipulators/StandardInventoryManipulator.java @@ -0,0 +1,160 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.core.inventory.manipulators; + +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import forestry.core.inventory.filters.IStackFilter; +import forestry.core.inventory.iterators.IExtInvSlot; +import forestry.core.inventory.iterators.InventoryIterator; +import forestry.core.utils.InventoryUtil; + +/** + * @author CovertJaguar + */ +public class StandardInventoryManipulator extends InventoryManipulator { + + private final IInventory inv; + + protected StandardInventoryManipulator(IInventory inv) { + this.inv = inv; + } + + @Override + public Iterator iterator() { + return InventoryIterator.getIterable(inv).iterator(); + } + + @Override + protected ItemStack addStack(ItemStack stack, boolean doAdd) { + if (stack == null || stack.stackSize <= 0) { + return null; + } + stack = stack.copy(); + List filledSlots = new ArrayList(inv.getSizeInventory()); + List emptySlots = new ArrayList(inv.getSizeInventory()); + for (IExtInvSlot slot : this) { + if (slot.canPutStackInSlot(stack)) { + if (slot.getStackInSlot() == null) { + emptySlots.add(slot); + } else { + filledSlots.add(slot); + } + } + } + + int injected = 0; + injected = tryPut(filledSlots, stack, injected, doAdd); + injected = tryPut(emptySlots, stack, injected, doAdd); + stack.stackSize -= injected; + if (stack.stackSize <= 0) { + return null; + } + return stack; + } + + private int tryPut(List slots, ItemStack stack, int injected, boolean doAdd) { + if (injected >= stack.stackSize) { + return injected; + } + for (IExtInvSlot slot : slots) { + ItemStack stackInSlot = slot.getStackInSlot(); + if (stackInSlot == null || InventoryUtil.isItemEqual(stackInSlot, stack)) { + int used = addToSlot(slot, stack, stack.stackSize - injected, doAdd); + if (used > 0) { + injected += used; + if (injected >= stack.stackSize) { + return injected; + } + } + } + } + return injected; + } + + /** + * @param available Amount we can move + * @return Return the number of items moved. + */ + private int addToSlot(IExtInvSlot slot, ItemStack stack, int available, boolean doAdd) { + int max = Math.min(stack.getMaxStackSize(), inv.getInventoryStackLimit()); + + ItemStack stackInSlot = slot.getStackInSlot(); + if (stackInSlot == null) { + int wanted = Math.min(available, max); + if (doAdd) { + stackInSlot = stack.copy(); + stackInSlot.stackSize = wanted; + slot.setStackInSlot(stackInSlot); + } + return wanted; + } + + if (!InventoryUtil.isItemEqual(stack, stackInSlot)) { + return 0; + } + + int wanted = max - stackInSlot.stackSize; + if (wanted <= 0) { + return 0; + } + + if (wanted > available) { + wanted = available; + } + + if (doAdd) { + stackInSlot.stackSize += wanted; + slot.setStackInSlot(stackInSlot); + } + return wanted; + } + + @Override + protected List removeItem(IStackFilter filter, int maxAmount, boolean doRemove) { + int amountNeeded = maxAmount; + List outputList = new ArrayList(); + for (IExtInvSlot slot : this) { + if (amountNeeded <= 0) { + break; + } + ItemStack stack = slot.getStackInSlot(); + if (stack != null && stack.stackSize > 0 && slot.canTakeStackFromSlot(stack) && filter.apply(stack)) { + ItemStack output = stack.copy(); + if (output.stackSize >= amountNeeded) { + output.stackSize = amountNeeded; + if (doRemove) { + stack.stackSize -= amountNeeded; + if (stack.stackSize <= 0) { + stack = null; + } + slot.setStackInSlot(stack); + } + amountNeeded = 0; + outputList.add(output); + } else { + amountNeeded -= output.stackSize; + outputList.add(output); + if (doRemove) { + slot.setStackInSlot(null); + } + } + } + } + return outputList; + } + +} diff --git a/src/main/java/forestry/core/inventory/wrappers/ChestWrapper.java b/src/main/java/forestry/core/inventory/wrappers/ChestWrapper.java index daa49cfdf..a637e9836 100755 --- a/src/main/java/forestry/core/inventory/wrappers/ChestWrapper.java +++ b/src/main/java/forestry/core/inventory/wrappers/ChestWrapper.java @@ -219,4 +219,4 @@ public class ChestWrapper implements IInventory { public void clear() { } -} +} \ No newline at end of file diff --git a/src/main/java/forestry/core/inventory/wrappers/InvWrapperBase.java b/src/main/java/forestry/core/inventory/wrappers/InvWrapperBase.java new file mode 100644 index 000000000..530bcfff0 --- /dev/null +++ b/src/main/java/forestry/core/inventory/wrappers/InvWrapperBase.java @@ -0,0 +1,134 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ + +package forestry.core.inventory.wrappers; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IChatComponent; + +/** + * Created by CovertJaguar on 3/6/2016 for Railcraft. + */ +public abstract class InvWrapperBase implements IInventory { + + private final IInventory inv; + private boolean checkItems = true; + + public InvWrapperBase(IInventory inv) { + this(inv, true); + } + + public InvWrapperBase(IInventory inv, boolean checkItems) { + this.inv = inv; + this.checkItems = checkItems; + } + + public IInventory getBaseInventory() { + return inv; + } + + @Override + public int getSizeInventory() { + return inv.getSizeInventory(); + } + + @Override + public ItemStack getStackInSlot(int slot) { + return inv.getStackInSlot(slot); + } + + @Override + public ItemStack decrStackSize(int slot, int amount) { + return inv.decrStackSize(slot, amount); + } + + @Override + public ItemStack removeStackFromSlot(int slot) { + return inv.removeStackFromSlot(slot); + } + + @Override + public void setInventorySlotContents(int slot, ItemStack itemstack) { + inv.setInventorySlotContents(slot, itemstack); + } + + @Override + public String getName() { + return inv.getName(); + } + + @Override + public IChatComponent getDisplayName() { + return inv.getDisplayName(); + } + + @Override + public int getInventoryStackLimit() { + return inv.getInventoryStackLimit(); + } + + @Override + public void markDirty() { + inv.markDirty(); + } + + @Override + public boolean isUseableByPlayer(EntityPlayer entityplayer) { + return inv.isUseableByPlayer(entityplayer); + } + + @Override + public void openInventory(EntityPlayer player) { + inv.openInventory(player); + } + + @Override + public void closeInventory(EntityPlayer player) { + inv.closeInventory(player); + } + + @Override + public boolean hasCustomName() { + return inv.hasCustomName(); + } + + @Override + public boolean isItemValidForSlot(int slot, ItemStack stack) { + return !checkItems || inv.isItemValidForSlot(slot, stack); + } + + @Override + public int getField(int id) { + return inv.getField(id); + } + + @Override + public void setField(int id, int value) { + inv.setField(id, value); + } + + @Override + public int getFieldCount() { + return inv.getFieldCount(); + } + + @Override + public void clear() { + inv.clear(); + } + + public boolean checkItems() { + return checkItems; + } +} + diff --git a/src/main/java/forestry/core/inventory/wrappers/InventoryCopy.java b/src/main/java/forestry/core/inventory/wrappers/InventoryCopy.java index 7d40e2be1..5f51ca9f7 100755 --- a/src/main/java/forestry/core/inventory/wrappers/InventoryCopy.java +++ b/src/main/java/forestry/core/inventory/wrappers/InventoryCopy.java @@ -10,133 +10,56 @@ ******************************************************************************/ package forestry.core.inventory.wrappers; -import net.minecraft.entity.player.EntityPlayer; +import forestry.core.inventory.InventoryPlain; +import forestry.core.inventory.iterators.IExtInvSlot; +import forestry.core.inventory.iterators.InventoryIterator; import net.minecraft.inventory.IInventory; import net.minecraft.item.ItemStack; -import net.minecraft.util.IChatComponent; - -import forestry.core.utils.InventoryUtil; /** * Creates a deep copy of an existing IInventory. - * + *

* Useful for performing inventory manipulations and then examining the results * without affecting the original inventory. * * @author CovertJaguar */ -public class InventoryCopy implements IInventory { +public class InventoryCopy extends InvWrapperBase { - private final IInventory orignal; - private final ItemStack contents[]; + private InventoryPlain copy; - public InventoryCopy(IInventory orignal) { - this.orignal = orignal; - contents = new ItemStack[orignal.getSizeInventory()]; - InventoryUtil.deepCopyInventoryContents(orignal, this); - } + public InventoryCopy(IInventory original) { + super(original); + this.copy = new InventoryPlain(original.getSizeInventory()); + for (IExtInvSlot slot : InventoryIterator.getIterable(original)) { + ItemStack stack = slot.getStackInSlot(); + if (stack != null) { + copy.setInventorySlotContents(slot.getIndex(), stack.copy()); + } + } + } - @Override - public int getSizeInventory() { - return contents.length; - } + @Override + public void setInventorySlotContents(int slot, ItemStack itemstack) { + copy.setInventorySlotContents(slot, itemstack); + } - @Override - public ItemStack getStackInSlot(int i) { - return contents[i]; - } + @Override + public ItemStack getStackInSlot(int slot) { + return copy.getStackInSlot(slot); + } - @Override - public ItemStack decrStackSize(int i, int j) { - if (contents[i] != null) { - if (contents[i].stackSize <= j) { - ItemStack itemstack = contents[i]; - contents[i] = null; - markDirty(); - return itemstack; - } - ItemStack itemstack1 = contents[i].splitStack(j); - if (contents[i].stackSize <= 0) { - contents[i] = null; - } - markDirty(); - return itemstack1; - } else { - return null; - } - } + @Override + public ItemStack decrStackSize(int slot, int amount) { + return copy.decrStackSize(slot, amount); + } - @Override - public void setInventorySlotContents(int i, ItemStack itemstack) { - contents[i] = itemstack; - if (itemstack != null && itemstack.stackSize > getInventoryStackLimit()) { - itemstack.stackSize = getInventoryStackLimit(); - } - markDirty(); - } + @Override + public ItemStack removeStackFromSlot(int slot) { + return copy.removeStackFromSlot(slot); + } - @Override - public String getName() { - return orignal.getName(); - } - - @Override - public IChatComponent getDisplayName() { - return orignal.getDisplayName(); - } - - @Override - public int getInventoryStackLimit() { - return orignal.getInventoryStackLimit(); - } - - @Override + @Override public void markDirty() { - } - - @Override - public boolean isUseableByPlayer(EntityPlayer entityplayer) { - return true; - } - - @Override - public void openInventory(EntityPlayer entityplayer) { - } - - @Override - public void closeInventory(EntityPlayer entityplayer) { - } - - @Override - public ItemStack removeStackFromSlot(int slot) { - return orignal.removeStackFromSlot(slot); - } - - @Override - public boolean hasCustomName() { - return orignal.hasCustomName(); - } - - @Override - public boolean isItemValidForSlot(int slot, ItemStack stack) { - return orignal.isItemValidForSlot(slot, stack); - } - - @Override - public int getField(int id) { - return 0; - } - - @Override - public int getFieldCount() { - return 0; - } - - @Override - public void clear() { - } - - @Override - public void setField(int id, int value) { - } + } } diff --git a/src/main/java/forestry/core/inventory/wrappers/InventoryIterator.java b/src/main/java/forestry/core/inventory/wrappers/InventoryIterator.java deleted file mode 100755 index ef32ff9cf..000000000 --- a/src/main/java/forestry/core/inventory/wrappers/InventoryIterator.java +++ /dev/null @@ -1,101 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2011-2014 SirSengir. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser Public License v3 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl-3.0.txt - * - * Various Contributors including, but not limited to: - * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges - ******************************************************************************/ -package forestry.core.inventory.wrappers; - -import java.util.Iterator; - -import net.minecraft.inventory.IInventory; -import net.minecraft.inventory.ISidedInventory; -import net.minecraft.item.ItemStack; - -/** - * @author CovertJaguar - */ -public class InventoryIterator implements Iterable { - - public static Iterable getIterable(IInventory inv) { - if (inv instanceof ISidedInventory) { - return new SidedInventoryIterator((ISidedInventory) inv); - } - return new InventoryIterator(inv); - } - - private final IInventory inv; - private final int invSize; - - private InventoryIterator(IInventory inv) { - this.inv = inv; - this.invSize = inv != null ? inv.getSizeInventory() : 0; - } - - @Override - public Iterator iterator() { - return new Iterator() { - int slot = 0; - - @Override - public boolean hasNext() { - return slot < invSize; - } - - @Override - public IInvSlot next() { - return new InvSlot(slot++); - } - - @Override - public void remove() { - throw new UnsupportedOperationException("Remove not supported."); - } - - }; - } - - private class InvSlot implements IInvSlot { - - private final int slot; - - public InvSlot(int slot) { - this.slot = slot; - } - - @Override - public ItemStack getStackInSlot() { - return inv.getStackInSlot(slot); - } - - @Override - public void setStackInSlot(ItemStack stack) { - inv.setInventorySlotContents(slot, stack); - } - - @Override - public boolean canPutStackInSlot(ItemStack stack) { - return inv.isItemValidForSlot(slot, stack); - } - - @Override - public boolean canTakeStackFromSlot(ItemStack stack) { - return true; - } - - @Override - public ItemStack decreaseStackInSlot() { - return inv.decrStackSize(slot, 1); - } - - @Override - public int getIndex() { - return slot; - } - - } -} diff --git a/src/main/java/forestry/core/inventory/wrappers/InventoryMapper.java b/src/main/java/forestry/core/inventory/wrappers/InventoryMapper.java index 7c657b53e..60e2f6571 100755 --- a/src/main/java/forestry/core/inventory/wrappers/InventoryMapper.java +++ b/src/main/java/forestry/core/inventory/wrappers/InventoryMapper.java @@ -1,20 +1,15 @@ -/******************************************************************************* - * Copyright (c) 2011-2014 SirSengir. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser Public License v3 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl-3.0.txt - * - * Various Contributors including, but not limited to: - * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges - ******************************************************************************/ +/* + * Copyright (c) CovertJaguar, 2014 http://railcraft.info + * + * This code is the property of CovertJaguar + * and may only be used with explicit written + * permission unless otherwise specified on the + * license page at http://railcraft.info/wiki/info:license. + */ package forestry.core.inventory.wrappers; -import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.IInventory; import net.minecraft.item.ItemStack; -import net.minecraft.util.EnumFacing; -import net.minecraft.util.IChatComponent; /** * Wrapper class used to specify part of an existing inventory to be treated as @@ -23,152 +18,72 @@ import net.minecraft.util.IChatComponent; * * @author CovertJaguar */ -public class InventoryMapper implements IInventory { +public class InventoryMapper extends InvWrapperBase implements IInventory { - private final IInventory inv; - private final int start; - private final int size; - private int stackSizeLimit = -1; - private boolean checkItems = true; + private final IInventory inv; + private final int start; + private final int size; + private int stackSizeLimit = -1; - public InventoryMapper(IInventory inv, EnumFacing side) { - this(inv, getInventoryStart(inv, side), getInventorySize(inv, side)); - } + public InventoryMapper(IInventory inv) { + this(inv, 0, inv.getSizeInventory(), true); + } - public InventoryMapper(IInventory inv) { - this(inv, 0, inv.getSizeInventory(), true); - } + public InventoryMapper(IInventory inv, boolean checkItems) { + this(inv, 0, inv.getSizeInventory(), checkItems); + } - public InventoryMapper(IInventory inv, boolean checkItems) { - this(inv, 0, inv.getSizeInventory(), checkItems); - } + /** + * Creates a new InventoryMapper + * + * @param inv The backing inventory + * @param start The starting index + * @param size The size of the new inventory, take care not to exceed the + * end of the backing inventory + */ + public InventoryMapper(IInventory inv, int start, int size) { + this(inv, start, size, true); + } - /** - * Creates a new InventoryMapper - * - * @param inv The backing inventory - * @param start The starting index - * @param size The size of the new inventory, take care not to exceed the - * end of the backing inventory - */ - public InventoryMapper(IInventory inv, int start, int size) { - this(inv, start, size, true); - } + public InventoryMapper(IInventory inv, int start, int size, boolean checkItems) { + super(inv, checkItems); + this.inv = inv; + this.start = start; + this.size = size; + } - public InventoryMapper(IInventory inv, int start, int size, boolean checkItems) { - this.inv = inv; - this.start = start; - this.size = size; - this.checkItems = checkItems; - } + @Override + public int getSizeInventory() { + return size; + } - protected static int getInventorySize(IInventory inv, EnumFacing side) { - return inv.getSizeInventory(); - } + @Override + public ItemStack getStackInSlot(int slot) { + return inv.getStackInSlot(start + slot); + } - protected static int getInventoryStart(IInventory inv, EnumFacing side) { - return 0; - } + @Override + public ItemStack decrStackSize(int slot, int amount) { + return inv.decrStackSize(start + slot, amount); + } - public IInventory getBaseInventory() { - return inv; - } + @Override + public void setInventorySlotContents(int slot, ItemStack itemstack) { + inv.setInventorySlotContents(start + slot, itemstack); + } - @Override - public int getSizeInventory() { - return size; - } + public void setStackSizeLimit(int limit) { + stackSizeLimit = limit; + } - @Override - public ItemStack getStackInSlot(int slot) { - return inv.getStackInSlot(start + slot); - } + @Override + public int getInventoryStackLimit() { + return stackSizeLimit > 0 ? stackSizeLimit : inv.getInventoryStackLimit(); + } - @Override - public ItemStack decrStackSize(int slot, int amount) { - return inv.decrStackSize(start + slot, amount); - } - - @Override - public void setInventorySlotContents(int slot, ItemStack itemstack) { - inv.setInventorySlotContents(start + slot, itemstack); - } - - @Override - public String getName() { - return inv.getName(); - } - - @Override - public IChatComponent getDisplayName() { - return inv.getDisplayName(); - } - - public void setStackSizeLimit(int limit) { - stackSizeLimit = limit; - } - - @Override - public int getInventoryStackLimit() { - return stackSizeLimit > 0 ? stackSizeLimit : inv.getInventoryStackLimit(); - } - - @Override - public void markDirty() { - inv.markDirty(); - } - - @Override - public boolean isUseableByPlayer(EntityPlayer entityplayer) { - return inv.isUseableByPlayer(entityplayer); - } - - @Override - public void openInventory(EntityPlayer entityplayer) { - inv.openInventory(entityplayer); - } - - @Override - public void closeInventory(EntityPlayer entityplayer) { - inv.closeInventory(entityplayer); - } - - @Override - public ItemStack removeStackFromSlot(int slot) { - return inv.removeStackFromSlot(start + slot); - } - - @Override - public boolean hasCustomName() { - return inv.hasCustomName(); - } - - @Override - public boolean isItemValidForSlot(int slot, ItemStack stack) { - if (checkItems) { - return inv.isItemValidForSlot(start + slot, stack); - } - return true; - } - - @Override - public int getField(int id) { - return inv.getField(id); - } - - @Override - public int getFieldCount() { - return inv.getFieldCount(); - } - - @Override - public void clear() { - inv.clear(); - } - - @Override - public void setField(int id, int value) { - inv.setField(id, value); - } + @Override + public boolean isItemValidForSlot(int slot, ItemStack stack) { + return !checkItems() || inv.isItemValidForSlot(start + slot, stack); + } } diff --git a/src/main/java/forestry/core/inventory/wrappers/SidedInventoryIterator.java b/src/main/java/forestry/core/inventory/wrappers/SidedInventoryIterator.java deleted file mode 100755 index cd8694975..000000000 --- a/src/main/java/forestry/core/inventory/wrappers/SidedInventoryIterator.java +++ /dev/null @@ -1,93 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2011-2014 SirSengir. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser Public License v3 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl-3.0.txt - * - * Various Contributors including, but not limited to: - * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges - ******************************************************************************/ -package forestry.core.inventory.wrappers; - -import java.util.Iterator; - -import net.minecraft.inventory.ISidedInventory; -import net.minecraft.item.ItemStack; -import net.minecraft.util.EnumFacing; - -/** - * @author CovertJaguar - */ -public class SidedInventoryIterator implements Iterable { - - private final ISidedInventory inv; - - SidedInventoryIterator(ISidedInventory inv) { - this.inv = inv; - } - - @Override - public Iterator iterator() { - return new Iterator() { - final int[] slots = inv.getSlotsForFace(EnumFacing.DOWN); - int index = 0; - - @Override - public boolean hasNext() { - return slots != null && index < slots.length; - } - - @Override - public IInvSlot next() { - return new InvSlot(slots[index++]); - } - - @Override - public void remove() { - throw new UnsupportedOperationException("Remove not supported."); - } - - }; - } - - private class InvSlot implements IInvSlot { - - private final int slot; - - public InvSlot(int slot) { - this.slot = slot; - } - - @Override - public ItemStack getStackInSlot() { - return inv.getStackInSlot(slot); - } - - @Override - public void setStackInSlot(ItemStack stack) { - inv.setInventorySlotContents(slot, stack); - } - - @Override - public boolean canPutStackInSlot(ItemStack stack) { - return inv.canInsertItem(slot, stack, EnumFacing.DOWN); - } - - @Override - public boolean canTakeStackFromSlot(ItemStack stack) { - return inv.canExtractItem(slot, stack, EnumFacing.DOWN); - } - - @Override - public ItemStack decreaseStackInSlot() { - return inv.decrStackSize(slot, 1); - } - - @Override - public int getIndex() { - return slot; - } - - } -} diff --git a/src/main/java/forestry/core/inventory/wrappers/SidedInventoryMapper.java b/src/main/java/forestry/core/inventory/wrappers/SidedInventoryMapper.java index 78c191bc3..5a4b8f770 100755 --- a/src/main/java/forestry/core/inventory/wrappers/SidedInventoryMapper.java +++ b/src/main/java/forestry/core/inventory/wrappers/SidedInventoryMapper.java @@ -10,12 +10,9 @@ ******************************************************************************/ package forestry.core.inventory.wrappers; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.inventory.IInventory; import net.minecraft.inventory.ISidedInventory; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumFacing; -import net.minecraft.util.IChatComponent; /** * Wrapper class used to bake the side variable into the object itself instead @@ -23,129 +20,34 @@ import net.minecraft.util.IChatComponent; * * @author CovertJaguar */ -public class SidedInventoryMapper implements ISidedInventory { +public class SidedInventoryMapper extends InvWrapperBase implements ISidedInventory { - private final ISidedInventory inv; - private final EnumFacing side; - private boolean checkItems = true; + private final ISidedInventory inv; + private final EnumFacing side; - public SidedInventoryMapper(ISidedInventory inv, EnumFacing side) { - this(inv, side, true); - } + public SidedInventoryMapper(ISidedInventory inv, EnumFacing side) { + this(inv, side, true); + } - public SidedInventoryMapper(ISidedInventory inv, EnumFacing side, boolean checkItems) { - this.inv = inv; - this.side = side; - this.checkItems = checkItems; - } + public SidedInventoryMapper(ISidedInventory inv, EnumFacing side, boolean checkItems) { + super(inv, checkItems); + this.inv = inv; + this.side = side; + } - public IInventory getBaseInventory() { - return inv; - } + @Override + public int[] getSlotsForFace(EnumFacing side) { + return inv.getSlotsForFace(side); + } - @Override - public int getSizeInventory() { - return inv.getSizeInventory(); - } + @Override + public boolean canInsertItem(int slot, ItemStack stack, EnumFacing s) { + return !checkItems() || inv.canInsertItem(slot, stack, side); + } - @Override - public ItemStack getStackInSlot(int slot) { - return inv.getStackInSlot(slot); - } - - @Override - public ItemStack decrStackSize(int slot, int amount) { - return inv.decrStackSize(slot, amount); - } - - @Override - public void setInventorySlotContents(int slot, ItemStack itemstack) { - inv.setInventorySlotContents(slot, itemstack); - } - - @Override - public String getName() { - return inv.getName(); - } - - @Override - public IChatComponent getDisplayName() { - return inv.getDisplayName(); - } - - @Override - public int getInventoryStackLimit() { - return inv.getInventoryStackLimit(); - } - - @Override - public void markDirty() { - inv.markDirty(); - } - - @Override - public boolean isUseableByPlayer(EntityPlayer entityplayer) { - return inv.isUseableByPlayer(entityplayer); - } - - @Override - public void openInventory(EntityPlayer entityplayer) { - inv.openInventory(entityplayer); - } - - @Override - public void closeInventory(EntityPlayer entityplayer) { - inv.closeInventory(entityplayer); - } - - @Override - public ItemStack removeStackFromSlot(int index) { - return inv.removeStackFromSlot(index); - } - - @Override - public boolean hasCustomName() { - return inv.hasCustomName(); - } - - @Override - public boolean isItemValidForSlot(int slot, ItemStack stack) { - return !checkItems || inv.isItemValidForSlot(slot, stack); - } - - @Override - public int[] getSlotsForFace(EnumFacing side) { - return inv.getSlotsForFace(side); - } - - @Override - public boolean canInsertItem(int slot, ItemStack stack, EnumFacing s) { - return !checkItems || inv.canInsertItem(slot, stack, side); - } - - @Override - public boolean canExtractItem(int slot, ItemStack stack, EnumFacing s) { - return !checkItems || inv.canExtractItem(slot, stack, side); - } - - @Override - public int getField(int id) { - return inv.getField(id); - } - - @Override - public void setField(int id, int value) { - inv.setField(id, value); - } - - @Override - public int getFieldCount() { - return inv.getFieldCount(); - } - - @Override - public void clear() { - inv.clear(); - } + @Override + public boolean canExtractItem(int slot, ItemStack stack, EnumFacing s) { + return !checkItems() || inv.canExtractItem(slot, stack, side); + } } diff --git a/src/main/java/forestry/core/items/ItemSolderingIron.java b/src/main/java/forestry/core/items/ItemSolderingIron.java index cde00a5cf..dfd4d9203 100644 --- a/src/main/java/forestry/core/items/ItemSolderingIron.java +++ b/src/main/java/forestry/core/items/ItemSolderingIron.java @@ -19,6 +19,7 @@ import forestry.core.circuits.ISolderingIron; import forestry.core.inventory.ItemInventorySolderingIron; public class ItemSolderingIron extends ItemWithGui implements ISolderingIron { + @Override public Object getGui(EntityPlayer player, ItemStack heldItem, int data) { return new GuiSolderingIron(player, new ItemInventorySolderingIron(player, heldItem)); diff --git a/src/main/java/forestry/core/models/baker/ModelBaker.java b/src/main/java/forestry/core/models/baker/ModelBaker.java index 92cf7b077..051059ffb 100644 --- a/src/main/java/forestry/core/models/baker/ModelBaker.java +++ b/src/main/java/forestry/core/models/baker/ModelBaker.java @@ -274,6 +274,9 @@ public class ModelBaker implements IModelBaker { } protected void addFace(@Nonnull EnumFacing face, boolean isEdge, Vector3f to, Vector3f from, float[] defUVs2, TextureAtlasSprite texture) { + if(texture == null) { + return; + } faces.add(new ModelBakerFace(face, isEdge, colorIndex, to, from, defUVs2, texture)); } @@ -284,6 +287,14 @@ public class ModelBaker implements IModelBaker { if (flip) { mr = ModelRotation.X0_Y180; } + + //Add baked models to the current model. + for(IBakedModel bakedModel : bakedModels){ + for(EnumFacing gce : EnumFacing.VALUES){ + this.currentModel.getFaceQuads(gce).addAll(bakedModel.getFaceQuads(gce)); + } + this.currentModel.getGeneralQuads().addAll(bakedModel.getGeneralQuads()); + } for (ModelBakerFace face : faces) { final EnumFacing myFace = face.face; @@ -302,14 +313,6 @@ public class ModelBaker implements IModelBaker { } } - //Add baked models to the current model. - for(IBakedModel bakedModel : bakedModels){ - for(EnumFacing gce : EnumFacing.VALUES){ - this.currentModel.getFaceQuads(gce).addAll(bakedModel.getFaceQuads(gce)); - } - this.currentModel.getGeneralQuads().addAll(bakedModel.getGeneralQuads()); - } - return currentModel; } diff --git a/src/main/java/forestry/core/tiles/TileAnalyzer.java b/src/main/java/forestry/core/tiles/TileAnalyzer.java index 2e14e5b40..ce39dd4e5 100644 --- a/src/main/java/forestry/core/tiles/TileAnalyzer.java +++ b/src/main/java/forestry/core/tiles/TileAnalyzer.java @@ -37,8 +37,8 @@ import forestry.core.fluids.tanks.FilteredTank; import forestry.core.gui.ContainerAnalyzer; import forestry.core.gui.GuiAnalyzer; import forestry.core.inventory.InventoryAnalyzer; -import forestry.core.inventory.wrappers.IInvSlot; -import forestry.core.inventory.wrappers.InventoryIterator; +import forestry.core.inventory.iterators.IExtInvSlot; +import forestry.core.inventory.iterators.InventoryIterator; import forestry.core.inventory.wrappers.InventoryMapper; import forestry.core.network.DataInputStreamForestry; import forestry.core.network.DataOutputStreamForestry; @@ -132,8 +132,8 @@ public class TileAnalyzer extends TilePowered implements ISidedInventory, ILiqui return true; } - private IInvSlot getInputSlot() { - for (IInvSlot slot : InventoryIterator.getIterable(invInput)) { + private IExtInvSlot getInputSlot() { + for (IExtInvSlot slot : InventoryIterator.getIterable(invInput)) { ItemStack inputStack = slot.getStackInSlot(); if (AlleleManager.alleleRegistry.isIndividual(inputStack)) { return slot; @@ -197,7 +197,7 @@ public class TileAnalyzer extends TilePowered implements ISidedInventory, ILiqui return; } - IInvSlot slot = getInputSlot(); + IExtInvSlot slot = getInputSlot(); if (slot == null) { return; } diff --git a/src/main/java/forestry/core/utils/InventoryUtil.java b/src/main/java/forestry/core/utils/InventoryUtil.java index 5e63e265d..89168bdc4 100644 --- a/src/main/java/forestry/core/utils/InventoryUtil.java +++ b/src/main/java/forestry/core/utils/InventoryUtil.java @@ -12,6 +12,7 @@ package forestry.core.utils; import java.util.AbstractMap; import java.util.ArrayList; +import java.util.Collection; import java.util.List; import java.util.Map; @@ -36,11 +37,12 @@ import forestry.api.core.ForestryAPI; import forestry.core.circuits.ISocketable; import forestry.core.inventory.filters.ArrayStackFilter; import forestry.core.inventory.filters.IStackFilter; -import forestry.core.inventory.filters.StackFilter; +import forestry.core.inventory.filters.StandardStackFilters; +import forestry.core.inventory.iterators.IExtInvSlot; +import forestry.core.inventory.iterators.IInvSlot; +import forestry.core.inventory.iterators.InventoryIterator; import forestry.core.inventory.manipulators.InventoryManipulator; -import forestry.core.inventory.wrappers.IInvSlot; import forestry.core.inventory.wrappers.InventoryCopy; -import forestry.core.inventory.wrappers.InventoryIterator; import forestry.core.inventory.wrappers.SidedInventoryMapper; import forestry.core.tiles.AdjacentTileCache; import forestry.plugins.ForestryPluginUids; @@ -75,6 +77,13 @@ public abstract class InventoryUtil { public static boolean isWildcard(int damage) { return damage == -1 || damage == OreDictionary.WILDCARD_VALUE; } + + public static ItemStack makeSafe(ItemStack stack) { + if (stack.stackSize <= 0) { + return null; + } + return stack; + } /** * A more robust item comparison function. @@ -157,6 +166,22 @@ public abstract class InventoryUtil { return false; } + /** + * Returns true if the item is equal to any one of several possible matches. + * + * @param stack the ItemStack to test + * @param matches the ItemStacks to test against + * @return true if a match is found + */ + public static boolean isItemEqual(ItemStack stack, Collection matches) { + for (ItemStack match : matches) { + if (isItemEqual(stack, match)) { + return true; + } + } + return false; + } + /** * Places an ItemStack in a destination IInventory. Will attempt to move as * much of the stack as possible, returning any remainder. @@ -180,7 +205,7 @@ public abstract class InventoryUtil { */ public static boolean moveItemStack(IInventory source, IInventory dest) { InventoryManipulator im = InventoryManipulator.get(dest); - for (IInvSlot slot : InventoryIterator.getIterable(source)) { + for (IExtInvSlot slot : InventoryIterator.getIterable(source)) { ItemStack stack = slot.getStackInSlot(); if (stack != null) { ItemStack remainder = im.addStack(stack); @@ -190,6 +215,23 @@ public abstract class InventoryUtil { } return false; } + + /** + * Returns true if the inventory contains the specified item. + * + * @param inv the inventory The inventory to check + * @param item The ItemStack to look for + * @return true is exists + */ + public static boolean containsItem(IInventory inv, ItemStack item) { + for (IInvSlot slot : InventoryIterator.getIterable(inv)) { + ItemStack stack = slot.getStackInSlot(); + if (stack != null && isItemEqual(stack, item)) { + return true; + } + } + return false; + } /** * Attempts to move an ItemStack from one inventory to another. @@ -214,7 +256,7 @@ public abstract class InventoryUtil { * @return An ItemStack */ public static ItemStack removeOneItem(IInventory inv) { - return removeOneItem(inv, StackFilter.ALL); + return removeOneItem(inv, StandardStackFilters.ALL); } /** diff --git a/src/main/java/forestry/food/items/ItemInfuser.java b/src/main/java/forestry/food/items/ItemInfuser.java index 569e48748..121e88be9 100644 --- a/src/main/java/forestry/food/items/ItemInfuser.java +++ b/src/main/java/forestry/food/items/ItemInfuser.java @@ -12,13 +12,13 @@ package forestry.food.items; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; - import forestry.core.items.ItemWithGui; import forestry.food.gui.ContainerInfuser; import forestry.food.gui.GuiInfuser; import forestry.food.inventory.ItemInventoryInfuser; public class ItemInfuser extends ItemWithGui { + @Override public Object getGui(EntityPlayer player, ItemStack heldItem, int data) { return new GuiInfuser(player.inventory, new ItemInventoryInfuser(player, heldItem)); diff --git a/src/main/java/forestry/greenhouse/PluginGreenhouse.java b/src/main/java/forestry/greenhouse/PluginGreenhouse.java index a9fe9e1db..706a79220 100644 --- a/src/main/java/forestry/greenhouse/PluginGreenhouse.java +++ b/src/main/java/forestry/greenhouse/PluginGreenhouse.java @@ -10,7 +10,6 @@ ******************************************************************************/ package forestry.greenhouse; -import forestry.api.core.EnumCamouflageType; import forestry.api.greenhouse.GreenhouseManager; import forestry.api.greenhouse.IGreenhouseItemAccess; import forestry.core.config.Constants; @@ -22,6 +21,7 @@ import forestry.greenhouse.tiles.TileGreenhouseDoor; import forestry.greenhouse.tiles.TileGreenhouseDryer; import forestry.greenhouse.tiles.TileGreenhouseFan; import forestry.greenhouse.tiles.TileGreenhouseGearbox; +import forestry.greenhouse.tiles.TileGreenhouseHatch; import forestry.greenhouse.tiles.TileGreenhouseHeater; import forestry.greenhouse.tiles.TileGreenhousePlain; import forestry.greenhouse.tiles.TileGreenhouseSprinkler; @@ -70,6 +70,7 @@ public class PluginGreenhouse extends BlankForestryPlugin { GameRegistry.registerTileEntity(TileGreenhouseControl.class, "forestry.GreenhouseController"); GameRegistry.registerTileEntity(TileGreenhousePlain.class, "forestry.GreenhousePlain"); GameRegistry.registerTileEntity(TileGreenhouseDoor.class, "forestry.GreenhouseDoor"); + GameRegistry.registerTileEntity(TileGreenhouseHatch.class, "forestry.GreenhouseHatch"); } @Override @@ -96,16 +97,6 @@ public class PluginGreenhouse extends BlankForestryPlugin { greenhouseAccess.registerGreenhouseGlass(new ItemStack(Blocks.stained_glass, 1, 14)); greenhouseAccess.registerGreenhouseGlass(new ItemStack(Blocks.stained_glass, 1, 15)); - for(BlockGreenhouseType type : BlockGreenhouseType.VALUES){ - if(type == BlockGreenhouseType.GLASS){ - greenhouseAccess.addToCamouflageBlockBlackList(EnumCamouflageType.GLASS, blocks.getGreenhouseBlock(type)); - }else if(type == BlockGreenhouseType.DOOR){ - greenhouseAccess.addToCamouflageBlockBlackList(EnumCamouflageType.DOOR, blocks.getGreenhouseBlock(type)); - }else{ - greenhouseAccess.addToCamouflageBlockBlackList(EnumCamouflageType.DEFAULT, blocks.getGreenhouseBlock(type)); - } - } - proxy.initializeModels(); } diff --git a/src/main/java/forestry/greenhouse/blocks/BlockGreenhouse.java b/src/main/java/forestry/greenhouse/blocks/BlockGreenhouse.java index b6620645b..3126a5dae 100644 --- a/src/main/java/forestry/greenhouse/blocks/BlockGreenhouse.java +++ b/src/main/java/forestry/greenhouse/blocks/BlockGreenhouse.java @@ -42,18 +42,21 @@ import net.minecraftforge.common.property.IUnlistedProperty; import net.minecraftforge.common.property.Properties; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; - +import forestry.api.core.ICamouflageHandler; +import forestry.api.core.ICamouflagedBlock; import forestry.api.core.IModelManager; import forestry.api.multiblock.IGreenhouseComponent; import forestry.core.CreativeTabForestry; import forestry.core.blocks.BlockStructure; import forestry.core.blocks.propertys.UnlistedBlockAccess; import forestry.core.blocks.propertys.UnlistedBlockPos; +import forestry.greenhouse.multiblock.IGreenhouseControllerInternal; import forestry.greenhouse.tiles.TileGreenhouseControl; import forestry.greenhouse.tiles.TileGreenhouseDoor; import forestry.greenhouse.tiles.TileGreenhouseDryer; import forestry.greenhouse.tiles.TileGreenhouseFan; import forestry.greenhouse.tiles.TileGreenhouseGearbox; +import forestry.greenhouse.tiles.TileGreenhouseHatch; import forestry.greenhouse.tiles.TileGreenhouseHeater; import forestry.greenhouse.tiles.TileGreenhousePlain; import forestry.greenhouse.tiles.TileGreenhouseSprinkler; @@ -192,6 +195,9 @@ public abstract class BlockGreenhouse extends BlockStructure { return new TileGreenhouseControl(); case DOOR: return new TileGreenhouseDoor(); + case HATCH_INPUT: + case HATCH_OUTPUT: + return new TileGreenhouseHatch(); default: return new TileGreenhousePlain(); } @@ -201,6 +207,20 @@ public abstract class BlockGreenhouse extends BlockStructure { public TileEntity createNewTileEntity(World world, int meta) { return createTileEntity(world, getStateFromMeta(meta)); } + + @Override + public int colorMultiplier(IBlockAccess world, BlockPos pos, int renderPass) { + TileEntity tile = world.getTileEntity(pos); + if(tile instanceof ICamouflagedBlock){ + if(renderPass < 100 && BlockGreenhouse.getCamouflageBlock(world, pos) != null){ + return Block.getBlockFromItem(BlockGreenhouse.getCamouflageBlock(world, pos).getItem()).colorMultiplier(world, pos, renderPass); + } + + return super.colorMultiplier(world, pos, renderPass); + }else{ + return super.colorMultiplier(world, pos, renderPass); + } + } /* MODELS */ @Override @@ -259,6 +279,21 @@ public abstract class BlockGreenhouse extends BlockStructure { return block == this ? false : super.shouldSideBeRendered(worldIn, pos, side); } + + public static ItemStack getCamouflageBlock(IBlockAccess world, BlockPos pos){ + TileEntity tile = world.getTileEntity(pos); + if(tile instanceof IGreenhouseComponent && tile instanceof ICamouflageHandler && tile instanceof ICamouflagedBlock){ + G greenhouse = (G) tile; + IGreenhouseControllerInternal greenhouseController = (IGreenhouseControllerInternal) greenhouse.getMultiblockLogic().getController(); + + ICamouflageHandler camouflageHandler = greenhouse; + if(greenhouse.getCamouflageBlock(greenhouse.getCamouflageType()) == null && greenhouseController.getCamouflageBlock(greenhouse.getCamouflageType()) != null){ + camouflageHandler = greenhouseController; + } + return camouflageHandler.getCamouflageBlock(greenhouse.getCamouflageType()); + } + return null; + } @SideOnly(Side.CLIENT) @Override diff --git a/src/main/java/forestry/greenhouse/blocks/BlockGreenhouseType.java b/src/main/java/forestry/greenhouse/blocks/BlockGreenhouseType.java index 7a7ea2810..9195879df 100644 --- a/src/main/java/forestry/greenhouse/blocks/BlockGreenhouseType.java +++ b/src/main/java/forestry/greenhouse/blocks/BlockGreenhouseType.java @@ -9,15 +9,22 @@ import javax.annotation.Nullable; import net.minecraft.block.state.IBlockState; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.BlockPos; +import net.minecraft.util.EnumFacing; +import net.minecraft.world.IBlockAccess; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; import forestry.core.render.TextureManager; import forestry.greenhouse.blocks.BlockGreenhouse.State; +import forestry.greenhouse.tiles.TileGreenhouseHatch; public enum BlockGreenhouseType { PLAIN, GLASS, + HATCH_INPUT(true), + HATCH_OUTPUT(true), GEARBOX(true), VALVE(true), FAN(true, true), @@ -40,6 +47,9 @@ public enum BlockGreenhouseType { private static final int TYPE_HEATER_ON = 7; private static final int TYPE_DRYER = 8; private static final int TYPE_CONTROL = 9; + private static final int TYPE_HATCH_INPUT = 10; + private static final int TYPE_HATCH_OUTPUT = 11; + private static final int TYPE_HATCH = 12; public final boolean hasOverlaySprite; public final boolean activatable; @@ -74,7 +84,10 @@ public enum BlockGreenhouseType { TextureManager.registerSprite("blocks/greenhouse/heater.off"), TextureManager.registerSprite("blocks/greenhouse/heater.off"), TextureManager.registerSprite("blocks/greenhouse/dryer"), - TextureManager.registerSprite("blocks/greenhouse/control") + TextureManager.registerSprite("blocks/greenhouse/control"), + TextureManager.registerSprite("blocks/greenhouse/hatch_input"), + TextureManager.registerSprite("blocks/greenhouse/hatch_output"), + TextureManager.registerSprite("blocks/greenhouse/hatch") ); } @@ -82,7 +95,11 @@ public enum BlockGreenhouseType { * @return The texture sprite from the type and the {@link IBlockState} of the greenhouse block */ @SideOnly(Side.CLIENT) - public static TextureAtlasSprite getSprite(BlockGreenhouseType type, @Nullable IBlockState state) { + public static TextureAtlasSprite getSprite(BlockGreenhouseType type, EnumFacing facing, @Nullable IBlockState state, @Nullable IBlockAccess world, @Nullable BlockPos pos) { + TileEntity tile = null; + if(world != null && pos != null){ + tile = world.getTileEntity(pos); + } switch (type) { case PLAIN: return sprites.get(TYPE_PLAIN); @@ -108,6 +125,21 @@ public enum BlockGreenhouseType { return sprites.get(TYPE_DRYER); case CONTROL: return sprites.get(TYPE_CONTROL); + case HATCH_OUTPUT: + case HATCH_INPUT: + if(tile == null || facing == null || !(tile instanceof TileGreenhouseHatch)){ + return sprites.get(TYPE_HATCH); + } + TileGreenhouseHatch hatch = (TileGreenhouseHatch) tile; + if(hatch.getOutwardsDir() == null){ + return sprites.get(TYPE_HATCH); + } + if(hatch.getOutwardsDir() == facing){ + return sprites.get(TYPE_HATCH_OUTPUT); + }else if(hatch.getOutwardsDir().getOpposite() == facing){ + return sprites.get(TYPE_HATCH_INPUT); + } + return null; default: return Minecraft.getMinecraft().getTextureMapBlocks().getMissingSprite(); } diff --git a/src/main/java/forestry/greenhouse/gui/ContainerGreenhouse.java b/src/main/java/forestry/greenhouse/gui/ContainerGreenhouse.java index 62bb027a6..7e1bb1624 100644 --- a/src/main/java/forestry/greenhouse/gui/ContainerGreenhouse.java +++ b/src/main/java/forestry/greenhouse/gui/ContainerGreenhouse.java @@ -22,7 +22,7 @@ public class ContainerGreenhouse extends ContainerTile { public ContainerGreenhouse(InventoryPlayer playerInventory, TileGreenhouse tile) { super(tile, playerInventory, 8, 84); - addSlotToContainer(new SlotFiltered(tile, 0, 53, 37)); + addSlotToContainer(new SlotFiltered(tile, 0, 125, 37)); } @Override diff --git a/src/main/java/forestry/greenhouse/gui/GuiGreenhouse.java b/src/main/java/forestry/greenhouse/gui/GuiGreenhouse.java index 297b19b5b..a89e5065b 100644 --- a/src/main/java/forestry/greenhouse/gui/GuiGreenhouse.java +++ b/src/main/java/forestry/greenhouse/gui/GuiGreenhouse.java @@ -26,17 +26,15 @@ public class GuiGreenhouse extends GuiForestryTitled { +public class ModelGreenhouse extends ModelBlockOverlay { public ModelGreenhouse() { super(BlockGreenhouse.class); @@ -39,26 +40,15 @@ public class ModelGreenhouse extends ModelBlockOverlay { @Override protected void bakeInventoryBlock(BlockGreenhouse block, ItemStack item, IModelBaker baker) { - bakeBlockModel(block, null, null, baker, null); + bakeBlockModel(block, null, null, null, baker, null); } @Override protected void bakeWorldBlock(BlockGreenhouse block, IBlockAccess world, BlockPos pos, IExtendedBlockState stateExtended, IModelBaker baker) { - TileEntity tile = world.getTileEntity(pos); - if(!(tile instanceof TileGreenhouse)){ - return; - } - TileGreenhouse greenhouse = (TileGreenhouse) tile; - IGreenhouseControllerInternal greenhouseController = greenhouse.getMultiblockLogic().getController(); - - ICamouflageHandler camouflageHandler = greenhouse; - if(greenhouse.getCamouflageBlock(greenhouse.getCamouflageType()) == null && greenhouseController.getCamouflageBlock(greenhouse.getCamouflageType()) != null){ - camouflageHandler = greenhouseController; - } - bakeBlockModel(block, pos, stateExtended, baker, camouflageHandler.getCamouflageBlock(greenhouse.getCamouflageType())); + bakeBlockModel(block, world, pos, stateExtended, baker, BlockGreenhouse.getCamouflageBlock(world, pos)); } - private void bakeBlockModel(@Nonnull BlockGreenhouse block, @Nullable BlockPos pos, @Nullable IExtendedBlockState stateExtended, @Nonnull IModelBaker baker, @Nullable ItemStack camouflageBlock){ + private void bakeBlockModel(@Nonnull BlockGreenhouse block, @Nullable IBlockAccess world, @Nullable BlockPos pos, @Nullable IExtendedBlockState stateExtended, @Nonnull IModelBaker baker, @Nullable ItemStack camouflageBlock){ if(camouflageBlock != null){ BlockModelShapes modelShapes = Minecraft.getMinecraft().getBlockRendererDispatcher().getBlockModelShapes(); @@ -67,18 +57,22 @@ public class ModelGreenhouse extends ModelBlockOverlay { //Bake the default blocks else if(block.getGreenhouseType() == BlockGreenhouseType.GLASS){ - TextureAtlasSprite glassSprite = BlockGreenhouseType.getSprite(BlockGreenhouseType.GLASS, null); + TextureAtlasSprite glassSprite = BlockGreenhouseType.getSprite(BlockGreenhouseType.GLASS, null, null, world, pos); - baker.addBlockModel(block, pos, BlockGreenhouseType.getSprite(BlockGreenhouseType.GLASS, null), 100); + baker.addBlockModel(block, pos, BlockGreenhouseType.getSprite(BlockGreenhouseType.GLASS, null, null, world, pos), 100); baker.setParticleSprite(glassSprite); }else{ - TextureAtlasSprite plainSprite = BlockGreenhouseType.getSprite(BlockGreenhouseType.PLAIN, null); + TextureAtlasSprite plainSprite = BlockGreenhouseType.getSprite(BlockGreenhouseType.PLAIN, null, null, world, pos); - baker.addBlockModel(block, pos, BlockGreenhouseType.getSprite(BlockGreenhouseType.PLAIN, null), 100); + baker.addBlockModel(block, pos, BlockGreenhouseType.getSprite(BlockGreenhouseType.PLAIN, null, null, world, pos), 100); baker.setParticleSprite(plainSprite); } if(block.getGreenhouseType().hasOverlaySprite){ - baker.addBlockModel(block, pos, BlockGreenhouseType.getSprite(block.getGreenhouseType(), stateExtended), 101); + TextureAtlasSprite[] sprite = new TextureAtlasSprite[6]; + for(EnumFacing facing : EnumFacing.VALUES){ + sprite[facing.ordinal()] = BlockGreenhouseType.getSprite(block.getGreenhouseType(), facing, stateExtended, world, pos); + } + baker.addBlockModel(block, pos, sprite, 101); } } diff --git a/src/main/java/forestry/greenhouse/tiles/TileGreenhouse.java b/src/main/java/forestry/greenhouse/tiles/TileGreenhouse.java index f1cd796f8..5ee23e194 100644 --- a/src/main/java/forestry/greenhouse/tiles/TileGreenhouse.java +++ b/src/main/java/forestry/greenhouse/tiles/TileGreenhouse.java @@ -71,23 +71,23 @@ public abstract class TileGreenhouse extends MultiblockTileEntityForestry implements IGreenhouseComponent, IHintSource, IErrorLogicSource, IRestrictedAccess, ICamouflageHandler, ICamouflagedBlock, IFluidHandler, IEnergyProvider, IEnergyReceiver { + + EnumFacing outwards; + private ItemStack camouflageBlock; + + @Nullable + private GameProfile owner; + + public TileGreenhouseHatch() { + super(new MultiblockLogicGreenhouse()); + outwards = null; + camouflageBlock = null; + } + + public EnumFacing getOutwardsDir() { + return outwards; + } + + @Override + public void onMachineAssembled(IMultiblockController multiblockController, BlockPos minCoord, BlockPos maxCoord) { + worldObj.notifyBlockOfStateChange(getPos(), worldObj.getBlockState(pos).getBlock()); + markDirty(); + + recalculateOutwardsDirection(minCoord, maxCoord); + } + + @Override + public void onMachineBroken() { + worldObj.notifyBlockOfStateChange(getPos(), worldObj.getBlockState(pos).getBlock()); + markDirty(); + outwards = null; + } + + /* SAVING & LOADING */ + @Override + public void readFromNBT(NBTTagCompound data) { + super.readFromNBT(data); + + if(data.hasKey("CamouflageBlock")){ + camouflageBlock = ItemStack.loadItemStackFromNBT(data.getCompoundTag("CamouflageBlock")); + } + + if (data.hasKey("owner")) { + NBTTagCompound ownerNbt = data.getCompoundTag("owner"); + this.owner = PlayerUtil.readGameProfileFromNBT(ownerNbt); + } + } + + @Override + public void writeToNBT(NBTTagCompound data) { + super.writeToNBT(data); + + + if(camouflageBlock != null){ + NBTTagCompound nbtTag = new NBTTagCompound(); + camouflageBlock.writeToNBT(nbtTag); + data.setTag("CamouflageBlock", nbtTag); + } + + if (this.owner != null) { + NBTTagCompound nbt = new NBTTagCompound(); + PlayerUtil.writeGameProfile(nbt, owner); + data.setTag("owner", nbt); + } + } + + /* IMultiblockComponent */ + @Nullable + @Override + public final GameProfile getOwner() { + return owner; + } + + public final void setOwner(@Nonnull GameProfile owner) { + this.owner = owner; + } + + /* CONSTRUCTION MATERIAL */ + @Override + public void setCamouflageBlock(EnumCamouflageType type, ItemStack camouflageBlock) { + this.camouflageBlock = camouflageBlock; + + if (worldObj != null) { + if (worldObj.isRemote) { + worldObj.markBlockForUpdate(getPos()); + } else { + Proxies.net.sendToServer(new PacketCamouflageUpdate(this, type)); + } + } + } + + @Override + public ItemStack getCamouflageBlock(EnumCamouflageType type) { + return camouflageBlock; + } + + /* TILEFORESTRY */ + @Override + protected void encodeDescriptionPacket(NBTTagCompound packetData) { + super.encodeDescriptionPacket(packetData); + if(camouflageBlock != null){ + NBTTagCompound nbtTag = new NBTTagCompound(); + camouflageBlock.writeToNBT(nbtTag); + packetData.setTag("CamouflageBlock", nbtTag); + } + } + + @Override + protected void decodeDescriptionPacket(NBTTagCompound packetData) { + super.decodeDescriptionPacket(packetData); + if(packetData.hasKey("CamouflageBlock")){ + setCamouflageBlock(getCamouflageType(), ItemStack.loadItemStackFromNBT(packetData.getCompoundTag("CamouflageBlock"))); + } + } + + /* IHintSource */ + @Override + public List getHints() { + return Config.hints.get("greenhouse"); + } + + /* IErrorLogicSource */ + @Override + public IErrorLogic getErrorLogic() { + return getMultiblockLogic().getController().getErrorLogic(); + } + + @Override + public IAccessHandler getAccessHandler() { + return getMultiblockLogic().getController().getAccessHandler(); + } + + @Override + public void onSwitchAccess(EnumAccess oldAccess, EnumAccess newAccess) { + getMultiblockLogic().getController().onSwitchAccess(oldAccess, newAccess); + } + + @Override + public EnumCamouflageType getCamouflageType() { + if(getBlockType() instanceof BlockGreenhouse && ((BlockGreenhouse)getBlockType()).getGreenhouseType() == BlockGreenhouseType.GLASS){ + return EnumCamouflageType.GLASS; + } + return EnumCamouflageType.DEFAULT; + } + + private IInventory getOutwardsInventory(){ + if(getOutwardsTile() == null){ + return null; + } + return TileUtil.getInventoryFromTile(getOutwardsTile(), outwards.getOpposite()); + } + + private TileEntity getOutwardsTile(){ + if(outwards == null || worldObj == null || pos == null){ + return null; + } + return worldObj.getTileEntity(getPos().offset(outwards)); + } + + private IFluidHandler getOutwardFluidHandler(){ + TileEntity tile = getOutwardsTile(); + if(tile == null || !(tile instanceof IFluidHandler)){ + return null; + } + return (IFluidHandler) tile; + } + + private IEnergyConnection getOutwardEnergyConnection(){ + TileEntity tile = getOutwardsTile(); + if(tile == null || !(tile instanceof IEnergyConnection)){ + return null; + } + return (IEnergyConnection) tile; + } + + private IEnergyHandler getOutwardEnergyHandler(){ + TileEntity tile = getOutwardsTile(); + if(tile == null || !(tile instanceof IEnergyHandler)){ + return null; + } + return (IEnergyHandler) tile; + } + + private IEnergyReceiver getOutwardEnergyReceiver(){ + TileEntity tile = getOutwardsTile(); + if(tile == null || !(tile instanceof IEnergyReceiver)){ + return null; + } + return (IEnergyReceiver) tile; + } + + private IEnergyProvider getOutwardEnergyProvider(){ + TileEntity tile = getOutwardsTile(); + if(tile == null || !(tile instanceof IEnergyProvider)){ + return null; + } + return (IEnergyProvider) tile; + } + + public void recalculateOutwardsDirection(BlockPos minCoord, BlockPos maxCoord) { + outwards = null; + + int facesMatching = 0; + if(maxCoord.getX() == getPos().getX() || minCoord.getX() == getPos().getX()) { facesMatching++; } + if(maxCoord.getY() == getPos().getY() || minCoord.getY() == getPos().getY()) { facesMatching++; } + if(maxCoord.getZ() == getPos().getZ() || minCoord.getZ() == getPos().getZ()) { facesMatching++; } + if(facesMatching == 1){ + if(maxCoord.getX() == getPos().getX()) { + outwards = EnumFacing.EAST; + }else if(minCoord.getX() == getPos().getX()) { + outwards = EnumFacing.WEST; + }else if(maxCoord.getZ() == getPos().getZ()) { + outwards = EnumFacing.SOUTH; + }else if(minCoord.getZ() == getPos().getZ()) { + outwards = EnumFacing.NORTH; + }else if(maxCoord.getY() == getPos().getY()) { + outwards = EnumFacing.UP; + }else { + outwards = EnumFacing.DOWN; + } + } + + if(((BlockGreenhouse)getBlockType()).getGreenhouseType() != BlockGreenhouseType.HATCH_OUTPUT){ + outwards = outwards.getOpposite(); + } + } + + @Override + public T getCapability(Capability capability, EnumFacing facing) { + if(capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY && getOutwardsTile() != null){ + return getOutwardsTile().getCapability(capability, facing); + } + return super.getCapability(capability, facing); + } + + @Override + public boolean hasCapability(Capability capability, EnumFacing facing) { + if(capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY && getOutwardsTile() != null){ + return getOutwardsTile().hasCapability(capability, facing); + } + return super.hasCapability(capability, facing); + } + + @Override + public int getEnergyStored(EnumFacing from) { + IEnergyHandler handler = getOutwardEnergyHandler(); + if(handler == null) { + return 0; + } + return handler.getEnergyStored(from); + } + + @Override + public int getMaxEnergyStored(EnumFacing from) { + IEnergyHandler handler = getOutwardEnergyHandler(); + if(handler == null) { + return 0; + } + return handler.getMaxEnergyStored(from); + } + + @Override + public boolean canConnectEnergy(EnumFacing from) { + IEnergyConnection connection = getOutwardEnergyConnection(); + if(connection == null) { + return false; + } + return connection.canConnectEnergy(from); + } + + @Override + public int receiveEnergy(EnumFacing from, int maxReceive, boolean simulate) { + IEnergyReceiver receiver = getOutwardEnergyReceiver(); + if(receiver == null) { + return 0; + } + return receiver.receiveEnergy(from, maxReceive, simulate); + } + + @Override + public int extractEnergy(EnumFacing from, int maxExtract, boolean simulate) { + IEnergyProvider provider = getOutwardEnergyProvider(); + if(provider == null) { + return 0; + } + return provider.extractEnergy(from, maxExtract, simulate); + } + + @Override + public int fill(EnumFacing from, FluidStack resource, boolean doFill) { + IFluidHandler handler = getOutwardFluidHandler(); + if(handler == null){ + return 0; + } + return handler.fill(from, resource, doFill); + } + + @Override + public FluidStack drain(EnumFacing from, FluidStack resource, boolean doDrain) { + IFluidHandler handler = getOutwardFluidHandler(); + if(handler == null){ + return null; + } + return handler.drain(from, resource, doDrain); + } + + @Override + public FluidStack drain(EnumFacing from, int maxDrain, boolean doDrain) { + IFluidHandler handler = getOutwardFluidHandler(); + if(handler == null){ + return null; + } + return handler.drain(from, maxDrain, doDrain); + } + + @Override + public boolean canFill(EnumFacing from, Fluid fluid) { + IFluidHandler handler = getOutwardFluidHandler(); + if(handler == null){ + return false; + } + return handler.canFill(from, fluid); + } + + @Override + public boolean canDrain(EnumFacing from, Fluid fluid) { + IFluidHandler handler = getOutwardFluidHandler(); + if(handler == null){ + return false; + } + return handler.canDrain(from, fluid); + } + + @Override + public FluidTankInfo[] getTankInfo(EnumFacing from) { + IFluidHandler handler = getOutwardFluidHandler(); + if(handler == null){ + return null; + } + return handler.getTankInfo(from); + } + + +} diff --git a/src/main/java/forestry/mail/inventory/ItemInventoryLetter.java b/src/main/java/forestry/mail/inventory/ItemInventoryLetter.java index 34e1d32b2..db93a9eec 100644 --- a/src/main/java/forestry/mail/inventory/ItemInventoryLetter.java +++ b/src/main/java/forestry/mail/inventory/ItemInventoryLetter.java @@ -35,7 +35,7 @@ import forestry.mail.items.ItemStamps; public class ItemInventoryLetter extends ItemInventory implements IErrorSource, IHintSource { private ILetter letter; - public ItemInventoryLetter(EntityPlayer player, ItemStack itemstack) { + public ItemInventoryLetter(EntityPlayer player,ItemStack itemstack) { super(player, 0, itemstack); } diff --git a/src/main/java/forestry/mail/items/ItemCatalogue.java b/src/main/java/forestry/mail/items/ItemCatalogue.java index 8479dbeb3..6df081edd 100644 --- a/src/main/java/forestry/mail/items/ItemCatalogue.java +++ b/src/main/java/forestry/mail/items/ItemCatalogue.java @@ -12,7 +12,6 @@ package forestry.mail.items; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; - import forestry.core.items.ItemWithGui; import forestry.mail.gui.ContainerCatalogue; import forestry.mail.gui.GuiCatalogue; diff --git a/src/main/java/forestry/storage/gui/ContainerBackpack.java b/src/main/java/forestry/storage/gui/ContainerBackpack.java index 196ca6c0b..89f2a56d8 100755 --- a/src/main/java/forestry/storage/gui/ContainerBackpack.java +++ b/src/main/java/forestry/storage/gui/ContainerBackpack.java @@ -12,7 +12,6 @@ package forestry.storage.gui; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; - import forestry.core.gui.ContainerItemInventory; import forestry.core.gui.slots.SlotFilteredInventory; import forestry.storage.inventory.ItemInventoryBackpack; diff --git a/src/main/java/forestry/storage/items/ItemBackpack.java b/src/main/java/forestry/storage/items/ItemBackpack.java index c2e7ed149..8efe11753 100755 --- a/src/main/java/forestry/storage/items/ItemBackpack.java +++ b/src/main/java/forestry/storage/items/ItemBackpack.java @@ -29,7 +29,6 @@ import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.fml.common.eventhandler.Event; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; - import forestry.api.core.IModelManager; import forestry.api.storage.BackpackStowEvent; import forestry.api.storage.EnumBackpackType; @@ -38,8 +37,8 @@ import forestry.core.config.Config; import forestry.core.config.Constants; import forestry.core.gui.GuiHandler; import forestry.core.inventory.ItemInventory; -import forestry.core.inventory.wrappers.IInvSlot; -import forestry.core.inventory.wrappers.InventoryIterator; +import forestry.core.inventory.iterators.IExtInvSlot; +import forestry.core.inventory.iterators.InventoryIterator; import forestry.core.items.ItemWithGui; import forestry.core.tiles.TileUtil; import forestry.core.utils.InventoryUtil; @@ -175,7 +174,7 @@ public class ItemBackpack extends ItemWithGui { private static void tryChestTransfer(ItemInventoryBackpack backpackInventory, IInventory target) { - for (IInvSlot slot : InventoryIterator.getIterable(backpackInventory)) { + for (IExtInvSlot slot : InventoryIterator.getIterable(backpackInventory)) { ItemStack packStack = slot.getStackInSlot(); if (packStack == null) { continue; @@ -188,7 +187,7 @@ public class ItemBackpack extends ItemWithGui { private void tryChestReceive(ItemInventoryBackpack backpackInventory, IInventory target) { - for (IInvSlot slot : InventoryIterator.getIterable(target)) { + for (IExtInvSlot slot : InventoryIterator.getIterable(target)) { ItemStack targetStack = slot.getStackInSlot(); if (targetStack == null) { continue; diff --git a/src/main/resources/assets/forestry/textures/blocks/greenhouse/dryer.png b/src/main/resources/assets/forestry/textures/blocks/greenhouse/dryer.png index 659459c7d..e14829987 100644 Binary files a/src/main/resources/assets/forestry/textures/blocks/greenhouse/dryer.png and b/src/main/resources/assets/forestry/textures/blocks/greenhouse/dryer.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/greenhouse/fan.off.png b/src/main/resources/assets/forestry/textures/blocks/greenhouse/fan.off.png index 92e13e9f3..5b3f51d09 100644 Binary files a/src/main/resources/assets/forestry/textures/blocks/greenhouse/fan.off.png and b/src/main/resources/assets/forestry/textures/blocks/greenhouse/fan.off.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/greenhouse/fan.on.png b/src/main/resources/assets/forestry/textures/blocks/greenhouse/fan.on.png index f41110ebb..d5c163555 100644 Binary files a/src/main/resources/assets/forestry/textures/blocks/greenhouse/fan.on.png and b/src/main/resources/assets/forestry/textures/blocks/greenhouse/fan.on.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/greenhouse/hatch.png b/src/main/resources/assets/forestry/textures/blocks/greenhouse/hatch.png new file mode 100644 index 000000000..120d27d5b Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/greenhouse/hatch.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/greenhouse/hatch_input.png b/src/main/resources/assets/forestry/textures/blocks/greenhouse/hatch_input.png new file mode 100644 index 000000000..7cd6f9169 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/greenhouse/hatch_input.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/greenhouse/hatch_output.png b/src/main/resources/assets/forestry/textures/blocks/greenhouse/hatch_output.png new file mode 100644 index 000000000..ce537cda7 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/greenhouse/hatch_output.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/greenhouse/heater.off.png b/src/main/resources/assets/forestry/textures/blocks/greenhouse/heater.off.png index ef81898b3..5b2034610 100644 Binary files a/src/main/resources/assets/forestry/textures/blocks/greenhouse/heater.off.png and b/src/main/resources/assets/forestry/textures/blocks/greenhouse/heater.off.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/greenhouse/heater.on.png b/src/main/resources/assets/forestry/textures/blocks/greenhouse/heater.on.png index fc8f2eb7b..a5b619c52 100644 Binary files a/src/main/resources/assets/forestry/textures/blocks/greenhouse/heater.on.png and b/src/main/resources/assets/forestry/textures/blocks/greenhouse/heater.on.png differ diff --git a/src/main/resources/assets/forestry/textures/gui/greenhouse.png b/src/main/resources/assets/forestry/textures/gui/greenhouse.png index 98c00a995..91481bb29 100644 Binary files a/src/main/resources/assets/forestry/textures/gui/greenhouse.png and b/src/main/resources/assets/forestry/textures/gui/greenhouse.png differ