From 86a93b29c06ca08b810a87936ee936bc057f77bb Mon Sep 17 00:00:00 2001 From: Nedelosk Date: Wed, 16 Mar 2016 23:20:33 +0100 Subject: [PATCH] Add greenhouse hatch and add IItemHandler integreation, thanks to CovertJaguar --- .../apiculture/items/ItemBeealyzer.java | 6 +- .../multiblock/TileAlvearySwarmer.java | 6 +- .../core/inventory/InventoryObject.java | 35 ++ .../core/inventory/InventoryPlain.java | 10 +- .../inventory/ItemHandlerItemInventory.java} | 18 +- .../core/inventory/ItemInventory.java | 22 +- .../inventory/filters/ArrayStackFilter.java | 46 +- ...kFilter.java => ExclusionStackFilter.java} | 22 +- .../core/inventory/filters/IStackFilter.java | 15 +- .../filters/InventoryStackFilter.java | 32 ++ .../core/inventory/filters/StackFilter.java | 129 ++++-- .../filters/StandardStackFilters.java | 100 +++++ .../core/inventory/iterators/IExtInvSlot.java | 30 ++ .../{wrappers => iterators}/IInvSlot.java | 19 +- .../iterators/InventoryIterator.java | 60 +++ .../ItemHandlerInventoryIterator.java | 88 ++++ .../iterators/SidedInventoryIterator.java | 72 ++++ .../iterators/StandardInventoryIterator.java | 100 +++++ .../manipulators/InventoryManipulator.java | 247 +++++------ .../ItemHandlerInventoryManipulator.java | 106 +++++ .../StandardInventoryManipulator.java | 160 +++++++ .../core/inventory/wrappers/ChestWrapper.java | 2 +- .../inventory/wrappers/InvWrapperBase.java | 134 ++++++ .../inventory/wrappers/InventoryCopy.java | 145 ++----- .../inventory/wrappers/InventoryIterator.java | 101 ----- .../inventory/wrappers/InventoryMapper.java | 211 +++------ .../wrappers/SidedInventoryIterator.java | 93 ---- .../wrappers/SidedInventoryMapper.java | 144 +------ .../core/items/ItemSolderingIron.java | 1 + .../core/models/baker/ModelBaker.java | 19 +- .../forestry/core/tiles/TileAnalyzer.java | 10 +- .../forestry/core/utils/InventoryUtil.java | 52 ++- .../java/forestry/food/items/ItemInfuser.java | 2 +- .../forestry/greenhouse/PluginGreenhouse.java | 13 +- .../greenhouse/blocks/BlockGreenhouse.java | 37 +- .../blocks/BlockGreenhouseType.java | 36 +- .../greenhouse/gui/ContainerGreenhouse.java | 2 +- .../greenhouse/gui/GuiGreenhouse.java | 12 +- .../gui/widgets/WidgetCamouflageSlot.java | 2 +- .../greenhouse/models/ModelGreenhouse.java | 38 +- .../greenhouse/tiles/TileGreenhouse.java | 14 +- .../greenhouse/tiles/TileGreenhouseHatch.java | 399 ++++++++++++++++++ .../mail/inventory/ItemInventoryLetter.java | 2 +- .../forestry/mail/items/ItemCatalogue.java | 1 - .../storage/gui/ContainerBackpack.java | 1 - .../forestry/storage/items/ItemBackpack.java | 9 +- .../textures/blocks/greenhouse/dryer.png | Bin 15658 -> 398 bytes .../textures/blocks/greenhouse/fan.off.png | Bin 15188 -> 385 bytes .../textures/blocks/greenhouse/fan.on.png | Bin 15307 -> 475 bytes .../textures/blocks/greenhouse/hatch.png | Bin 0 -> 417 bytes .../blocks/greenhouse/hatch_input.png | Bin 0 -> 431 bytes .../blocks/greenhouse/hatch_output.png | Bin 0 -> 429 bytes .../textures/blocks/greenhouse/heater.off.png | Bin 15217 -> 407 bytes .../textures/blocks/greenhouse/heater.on.png | Bin 15281 -> 478 bytes .../forestry/textures/gui/greenhouse.png | Bin 4017 -> 3897 bytes 55 files changed, 1919 insertions(+), 884 deletions(-) create mode 100644 src/main/java/forestry/core/inventory/InventoryObject.java rename src/main/java/forestry/{greenhouse/models/ModelGreenhouseSprinkler.java => core/inventory/ItemHandlerItemInventory.java} (62%) rename src/main/java/forestry/core/inventory/filters/{InvertedStackFilter.java => ExclusionStackFilter.java} (65%) mode change 100755 => 100644 create mode 100644 src/main/java/forestry/core/inventory/filters/InventoryStackFilter.java create mode 100644 src/main/java/forestry/core/inventory/filters/StandardStackFilters.java create mode 100644 src/main/java/forestry/core/inventory/iterators/IExtInvSlot.java rename src/main/java/forestry/core/inventory/{wrappers => iterators}/IInvSlot.java (59%) mode change 100755 => 100644 create mode 100644 src/main/java/forestry/core/inventory/iterators/InventoryIterator.java create mode 100644 src/main/java/forestry/core/inventory/iterators/ItemHandlerInventoryIterator.java create mode 100644 src/main/java/forestry/core/inventory/iterators/SidedInventoryIterator.java create mode 100644 src/main/java/forestry/core/inventory/iterators/StandardInventoryIterator.java create mode 100644 src/main/java/forestry/core/inventory/manipulators/ItemHandlerInventoryManipulator.java create mode 100644 src/main/java/forestry/core/inventory/manipulators/StandardInventoryManipulator.java create mode 100644 src/main/java/forestry/core/inventory/wrappers/InvWrapperBase.java delete mode 100755 src/main/java/forestry/core/inventory/wrappers/InventoryIterator.java delete mode 100755 src/main/java/forestry/core/inventory/wrappers/SidedInventoryIterator.java create mode 100644 src/main/java/forestry/greenhouse/tiles/TileGreenhouseHatch.java create mode 100644 src/main/resources/assets/forestry/textures/blocks/greenhouse/hatch.png create mode 100644 src/main/resources/assets/forestry/textures/blocks/greenhouse/hatch_input.png create mode 100644 src/main/resources/assets/forestry/textures/blocks/greenhouse/hatch_output.png 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 659459c7d31b5df5c8660e86eb9a30805da4fc36..e14829987c4a1c5ae4d4664bcc4fe87b01df5b67 100644 GIT binary patch delta 331 zcmV-R0krM+Dx{Qj$}%ddl2CIhtAC2pG*$HmkPAs| z+wKwzK(p_A%3dzUaik~;DF}RuAYIojdJsTH2e=T1f%@38 ztc3uB6U>@N!vm1d_dRv40qD7|^LYoLBR5`K1K@_ z;e)yK5+Nf1`S7cBUO>-tl@Mz_;{nBc2l{oK*ad2RY9~eqkhqm3@?6zxUC!63-T;0T d+uScYJOSiJK0q^cGvfdN002ovPDHLkV1l})is=9V literal 15658 zcmeI3Uu+ab9LKi?u{2WKV8S1x90w8z?(OdF?%nNjceV72ZQ|9^mb8r$*xQ|L*WTS8 zw|niisL@IYAO@p?<$>UfV2I&CjV}fXK@%jz7=06hG0_Jx0%8oo1aS8LZl~8tgBYWk zOYU}m^PS)CxAU2q-|ju^p6;%v7B(zvpeSl#XGg3D9-EwR{e1Yl{P#NwJS@m`3|bV` z___0~JFu?t5sF%W)aVj+b_o1c%}^u8yyo_&^yu9r%sHhlICrRHiYvs43Gl0;>o9yX-m#WyoIS@3&G zA8)h)o`tiTF89PXmeN5h;vKf_jLa}&V`IKC-e+cq7*3KThV?UkKMi}()_B@h@^so- zSqxH+69bl-H8QqgraewvC1K|5h}Y{Rs(ec0N@XgE(pHHbq{!rz48!?Yrk0bYR(vwK zY_f1^n#zDANP)C%K|ijhUuM{}O>5YkC1pjPH8Gr%c)XIk=JlphHB(!5`zSKo4hrUzJNE~|p}Q8<*9wMK6ndUbN9MRJr`uN~x#S==0@=vG(?#Tg32vC3^(px9=% z&oq%j}v9iFN^Ft zmXlf56{Oe`i4iw7Lm!_OgX8=BoXiWdAh~0>dZIDl{?Qa$nNt*ZUsoJWm31?lQtYUa zQicGNNe_jYYNM-XWmU;-X41^U%K}k8%+zXjc@rQ_VTM1%@sb7R^*)`08cpdeAR% zA&~}>sL&h-L|Wlgl}@N?Fr)>QP*4n(6S;!TNc2qBfOStvy81X{(O|NG2m~c4Bxpqv zgLEh%gy>LEV(Ad4=^PM30Z|W?Q`87EBUOiC!PPqMTE%cJ7b;sX*gn0rEF_IWg~}*d z3po2P;w^8$N=d6!EXSv?k7Y%5YFkuwwg=F{%(T|(WmP;&ZpO^%oEw5-e3$#|ImU)T z8n?ZQp$ffb4`P|RJ*H$q>kwQabJ_XDsMFoh@L|Te7bJ~;U?MDK^zTiB&Z~kNQUuzs zYb?zwa3xBr&eA|rLWzLrmw+ynr}=KDfoEklSguh2-ZWHKu{x}zhkzDk$|EZ`{Fi2K zZuRhPH&Bgx%l}~JiaT+7O)S^hnKd-*JXXlC{=!RR>OoHp#JzmyGWc6m9^KE)ezFMLb~(SRuOVwgdjQIBpT z50V2h1KvR`=T5){N>f+9sW~bDt{Gb6xPc9=U$#v zM|3ZvBC$vk1PIK%w;&DQxE+J9)&{pWo`J9Bden}dI7Ll7PEjwvN>MlOz~j#pm18OD@-~W+ zrzmQ%`R3LyHp0HQJ7cYV`R_h>Yt!>P*`{45C%eTxSL%AevxiTNF8^fllKS)PjZ^2o zKXzd6_O-u8Us$#3+D}J1d#E+H+kO-3nt#YG$qedEn+}c-etjddyMF!YQ1jHye(nC) zyynyFgDh`vd95kjb*wSBr8U;1?mYh3g4OR|-g{`pdmj(>Zr*)%`+b|+FU+4>dhWxE zZ}e=~($Df2KTD6-@n?2CpkG=rwKU$_a^;mnE9UKg`IbHmo3x0bbQk6!I;T-4Nj sbpO(CL;8{H7jC|IxaAIi>%i4I>c@@ICs(WcAQ6h{Z10Ml*syK#FUF(^8UO$Q 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 92e13e9f322d65dc02babc7a0b57043c111ac9cb..5b3f51d093ecbb6cae8b790ff8e056906ca818ad 100644 GIT binary patch delta 318 zcmV-E0m1&%c7X$sB$F{ZEPn}bNLh0L01m?d01m?e$8V@)0000ObVXQnQ*UN;cVTj6 z0B~VxZgehgWpp4kE-)@O{ETDY0002vNkl#1nk3W&@ctCexYse+{6*#SQ{`Qg#N;+8>DHIP Q?EnA(07*qoM6N<$f~5qAy8r+H literal 15188 zcmeI3Ux*V&9LL96N_(JKp(ypiH6mDav%A@3lUhTF!rX0)+kP1XbJk{$7?f&vtwqcYWE!L*fXBH+bU(7oHt z1sJc3Gn@!?x(S(qbT89ol_3)eO0339Q6?$}g-A3Sj;>`wyb$4dkrR0~Br0KE35S^a zCy?wwck!~GQ~FXH>*4U1x_Va#gj&2|=D~=cH>*pVCOV z;0;aJI9Py1XgW6X6WaQfhAhXjhpbsrHsx6pqcusVo4MPLw^(eO+IBYVMhNOi+j`oW z(GukPplywmHMn6nn##&{vv-VKYjLJUa+O)f4y(p2Zmv>u^R_~5h2m(gN>>@Gj#bWB zRv}s2WxWlAOjnn;tC-c>4O6!&_7iaqcWJG6D;i9x4osr`D6zcA@^VIqC_+ey@N0NM z;dx(>T2CxS+R}~OXqy-!kHzry#ABfP(N#yCQxtz+UmRUia#p#hI!U9b<{?)y^Kq`# z=K3ertPSv276LT)DScbT@iI1hBZ0L!f=d7bsmng zF;&X3Fd7bvAxTmNQT8CF(|-3Ep;MMN;#La^T{~EGOGDvX!-@$)G^WKw7D{NL1OZ0a zn1oX5*=$VDq1#9#)JWtDHY3r~WdogiYQfjXor{i=>1s|7%Q1nKVyejIV&M>*m7*#e zl6aIemJLU<(MF0kVP>T2Hf*$8M}4~(?Pc#|+XkPT-r5ifhIc}h)UplT`bz{F1=u{& znkSa)6sKxiW&z_?)1Wi(T)k1l_W)EUp zIj5qQVP_ugkhxTTE$VbPJbavU{|gGnf3Og?y8GUiVQy7*Z_6<4g!=!Mp|y*(A=S)7 zJ;^mTaHC;vD_2|3>6O)})|r(UcmJFeRK;jVsb2L6ac)LiD|4;?fLo1)5wE{2@#w<| z?r+`IFXOI*WLLk8yS6<0O~Xl|W6m2W*6j0g|3PcV`!@8j2a{4HB1YmI-i&+n8dX>r zNEzrHw%zkYkm^3T(AIHqHb0iXnuY1$OZIrC!=-ur2!aQ1;F?|04Ar<^=AM^cmRIc1%PrAfF;(^ zonLK4eQ)%nIy2SlXWqDA?&BAwCSR7ri=`hUdrvL?@Idh$`SgvGcc-Sr#OZ(fnD=h- zN8yeu=g!^Uuist1>ioRRhpt>&`Sc5$#JBptpEz^-&D_PEt&yOlQM)+s?`d?afY8klv!68tc{ABI?gQpnq?4{uc z7k=?1*z(<pF7<5HgbW?9;ba!EL zWdLwtX>N2bZe?^JG%heMHvEiZ-v9ssJxN4CR5(wik=t^DKoCUzh$!eTcR?a1Mo`dH zw0JcB|NnHRhs3HxNaga-#jw<#)4PlS{42eSzsYr|stU{13cIET=YPJ`O@pE+biM&> z$_jVmDaI3nvEyOlhH$14oY@?%$>7=?Q*Vixzv>5Yk(-kwf#-RMq6mvT*C%6bw>Asb zLx57vaU6?T^2uC?`9Z&#a5LP1wG|+nY2*CShGyUQVWJAh)3F~wbDE}VK3~pyWkl$-8ff6e;w={ny4{+iy!p9iBi<{BX&a}Pn16951J07*qoM6N<$ Ef^?U_jQ{`u literal 15307 zcmeI3Ym5_B6vt;Z5!kSs)eshWXepY=V>&Z!r`=Avg=M=hVqx7!*bN4DI&<3{X*;De zOS>DwOJguGM&1w28Zo}`fsw$6#h?k0AQ%a5G$4L33X8mB2oOZXJ8id}z1zLn1dLzq zB<;+(|9j54^Sk%lnJ@ENpDnMU^zv``e(UKosbrB^8atG$B=KO~)1Bwb9I2 zE$J@$@=9x!kXtY$T31H!EE?Qz;Zj0Mv<9N5*>7HY;vmDQ`4#vUKc8B0(1*hGT zJ*>WBc;!vVA)(1%n@tC;N^7UC#|4H-CX=?L!=@&}4CnE97}n0%?KJE`YuzzjOwloI zMkdH$96!*cgc8>kHD)p5ib1tYue4f?M7bk-U(t9jQB2FSgA|#R7-u*e%M@~wrJPT^ zD-lT#O_mrC0Z|asHR#6`^ow_@x~g@mBc#m9BPND(5(wmS7aVUiS}?Vy*Q|sHvPcVh zYAxMyz%&6(?Mg_XW+l9p8HMg%S3>#884}4*MjSgxDI>TUO2#d{6f!g9h4(5{CxED{ zi569j_%f@kaS)-Ux;nk8EYB@gVzQdlW_lUaB|qQ!XuvP(zz5f(i)I}(>uKS5fwK!d zJDcSMmNf;*^h9C=R9Oji7l`5D1iQ-|!_*Uv0qaK=b#YWt%zaI9WJw6AiKwXil&Ba6 zOgt9$GWkYR&)ljKs?~^^fWrblhnFeTZ1PI4G@&7;>0(R*4SpYNuqlcxgm|}0c2u}& zCl4grEjfd9g(oD^BJZ$^jv&W7IAUE!)=X*n3IkVEj2=k0@uOu>dFT9i=Wz9&XZeT;jNVKTeN;jVCoJhaTY z9kfGq0@?#OnHJr^&boo*kUWr721S7|!&22N8eFa2rd15ra(ZWL1}lcP4hj(^y+g&t zga(ZItF#UlU~Wsx?O29Sx{d`=GWIr~WRwSxz08o-{IGJKSvO_)bdC-|Ccepi=mehW9eYvmm1U2NR)*D<5ncMpso2HVs2| zsQ+&o@~c?t6k}l^`YDd#jVZbhZgc5@BF!c*;|ZGC-kage9`Lz% z-obkrv>EkiR8k<)=2zf8tQq?W=gRt^LP5v&ksM7z)-f|xrq{A`4Q5*5OCNmSWO6T@ z!^$(ai#^PX{2e{as7Nf51Ob9K2`)SzL?yToAb6AD!t+5?f(rqHHwi90A4Da%5FmJy z;KK7kRDufuf;R~+JRd|QxDX(Clio;Q2`7lb?>3Y01I@Z!YvD(rltrp<3Q$zfvlO-VWs16UAD%B# zR2NH8mpUj)*g;X{>ZWB!YbmOzy}@7AlKT16%_kCX%`2<9`FPbg-j2TRwuwz+C(k%z zTXOV=Q}^$m{PU6R<)!k*)QV5~LMyI)yz^qo7kA!?94aZ3Cw`p^PZn$(Nw9Z-H)V%r3w(qVUyZ2P{)NMsv?WWJ(-!tp0+Z)Cv4^FeL z-|*`%t3tA!1?13G>ZJ2qteTj8p-Kv`#Zujo) zZXa{*P<89L>1Dp&z2nz8Pn_OQTj!rzx|ouVOsKn3w{P>9w|g%P{Izp;_q&n3Tax{K yRj+UCKfJS_owNG6+fcL6|M~om_5T89z|0>2 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 0000000000000000000000000000000000000000..120d27d5b988df1428d298536a6159bef43ab9f0 GIT binary patch literal 417 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 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 fc8f2eb7b0aa028b83ff94e8835e1c700f8411e6..a5b619c5236987dfd868350a59f802c10646e834 100644 GIT binary patch delta 413 zcmV;O0b>5Kcisb#B$F{ZD}Mk9a7bBm000id000id0mpBsWB>pF7<5HgbW?9;ba!EL zWdLwtX>N2bZe?^JG%heMHvEiZ-v9ssKuJVFR5(wil3P#0KoErq`v-VZ+ipv*OCv<3 z6_5u^6ZOFu?`TB4CmR3%A2{yp5)$pUL4Ej=)7kEsGt)Kz{0n38H-9Wep6A%?^)MI> zLE6M{G(xxARk~!*&vFDo@Qqfh1>3eu7!9aMmyXvMT-U{!#n4GpRhx1K&RxvfP4!%1 zkRgr}oUAiAj)M!EEtA~1OrFJ<`?^+};BM literal 15281 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