initial commit

java/src/game/inventory/InventoryBasic.java

@@ -0,0 +1,287 @@
+package game.inventory;
+
+import java.util.List;
+
+import game.collect.Lists;
+import game.entity.npc.EntityNPC;
+import game.item.ItemStack;
+
+public class InventoryBasic implements IInventory
+{
+    private String inventoryTitle;
+    private String inventoryComp;
+    private int slotsCount;
+    private ItemStack[] inventoryContents;
+    private List<IInvBasic> changeListeners;
+    private boolean hasCustomName;
+
+    public InventoryBasic(String title, boolean customName, int slotCount)
+    {
+        this.inventoryTitle = title;
+        this.hasCustomName = customName;
+        this.slotsCount = slotCount;
+        this.inventoryContents = new ItemStack[slotCount];
+    }
+
+    public InventoryBasic(String title, int slotCount)
+    {
+        this(title, true, slotCount);
+    }
+
+    /**
+     * Add a listener that will be notified when any item in this inventory is modified.
+     *  
+     * @param listener the listener to add
+     */
+    public void addInventoryChangeListener(IInvBasic listener)
+    {
+        if (this.changeListeners == null)
+        {
+            this.changeListeners = Lists.<IInvBasic>newArrayList();
+        }
+
+        this.changeListeners.add(listener);
+    }
+
+    /**
+     * removes the specified IInvBasic from receiving further change notices
+     *  
+     * @param listener the listener to remove
+     */
+    public void removeInventoryChangeListener(IInvBasic listener)
+    {
+        this.changeListeners.remove(listener);
+    }
+
+    /**
+     * Returns the stack in the given slot.
+     */
+    public ItemStack getStackInSlot(int index)
+    {
+        return index >= 0 && index < this.inventoryContents.length ? this.inventoryContents[index] : null;
+    }
+
+    /**
+     * Removes up to a specified number of items from an inventory slot and returns them in a new stack.
+     */
+    public ItemStack decrStackSize(int index, int count)
+    {
+        if (this.inventoryContents[index] != null)
+        {
+            if (this.inventoryContents[index].stackSize <= count)
+            {
+                ItemStack itemstack1 = this.inventoryContents[index];
+                this.inventoryContents[index] = null;
+                this.markDirty();
+                return itemstack1;
+            }
+            else
+            {
+                ItemStack itemstack = this.inventoryContents[index].splitStack(count);
+
+                if (this.inventoryContents[index].stackSize == 0)
+                {
+                    this.inventoryContents[index] = null;
+                }
+
+                this.markDirty();
+                return itemstack;
+            }
+        }
+        else
+        {
+            return null;
+        }
+    }
+
+    public ItemStack addStack(ItemStack stack)
+    {
+        ItemStack itemstack = stack.copy();
+
+        for (int i = 0; i < this.slotsCount; ++i)
+        {
+            ItemStack itemstack1 = this.getStackInSlot(i);
+
+            if (itemstack1 == null)
+            {
+                this.setInventorySlotContents(i, itemstack);
+                this.markDirty();
+                return null;
+            }
+
+            if (ItemStack.areItemsEqual(itemstack1, itemstack))
+            {
+                int j = Math.min(this.getInventoryStackLimit(), itemstack1.getMaxStackSize());
+                int k = Math.min(itemstack.stackSize, j - itemstack1.stackSize);
+
+                if (k > 0)
+                {
+                    itemstack1.stackSize += k;
+                    itemstack.stackSize -= k;
+
+                    if (itemstack.stackSize <= 0)
+                    {
+                        this.markDirty();
+                        return null;
+                    }
+                }
+            }
+        }
+
+        if (itemstack.stackSize != stack.stackSize)
+        {
+            this.markDirty();
+        }
+
+        return itemstack;
+    }
+
+    /**
+     * Removes a stack from the given slot and returns it.
+     */
+    public ItemStack removeStackFromSlot(int index)
+    {
+        if (this.inventoryContents[index] != null)
+        {
+            ItemStack itemstack = this.inventoryContents[index];
+            this.inventoryContents[index] = null;
+            return itemstack;
+        }
+        else
+        {
+            return null;
+        }
+    }
+
+    /**
+     * Sets the given item stack to the specified slot in the inventory (can be crafting or armor sections).
+     */
+    public void setInventorySlotContents(int index, ItemStack stack)
+    {
+        this.inventoryContents[index] = stack;
+
+        if (stack != null && stack.stackSize > this.getInventoryStackLimit())
+        {
+            stack.stackSize = this.getInventoryStackLimit();
+        }
+
+        this.markDirty();
+    }
+
+    /**
+     * Returns the number of slots in the inventory.
+     */
+    public int getSizeInventory()
+    {
+        return this.slotsCount;
+    }
+
+    /**
+     * Get the name of this object. For players this returns their username
+     */
+    public String getName()
+    {
+        return this.inventoryTitle;
+    }
+
+    /**
+     * Returns true if this thing is named
+     */
+    public boolean hasCustomName()
+    {
+        return this.hasCustomName;
+    }
+
+    /**
+     * Sets the name of this inventory. This is displayed to the client on opening.
+     */
+//    public void setCustomName(String inventoryTitleIn)
+//    {
+//        this.hasCustomName = true;
+//        this.inventoryTitle = inventoryTitleIn;
+//    }
+    
+    public void setCustomName(String inventoryCompIn)
+    {
+        this.hasCustomName = true;
+        this.inventoryComp = inventoryCompIn;
+    }
+
+    /**
+     * Get the formatted ChatComponent that will be used for the sender's username in chat
+     */
+    public String getCommandName()
+    {
+        return this.inventoryComp != null ? this.inventoryComp : this.getName();
+//        	((TextComponent)(this.hasCustomName() ? new TextComponent(this.getName()) : new TextComponent(this.getName())));
+    }
+
+    /**
+     * Returns the maximum stack size for a inventory slot. Seems to always be 64, possibly will be extended.
+     */
+    public int getInventoryStackLimit()
+    {
+        return ItemStack.MAX_SIZE;
+    }
+
+    /**
+     * For tile entities, ensures the chunk containing the tile entity is saved to disk later - the game won't think it
+     * hasn't changed and skip it.
+     */
+    public void markDirty()
+    {
+        if (this.changeListeners != null)
+        {
+            for (int i = 0; i < this.changeListeners.size(); ++i)
+            {
+                ((IInvBasic)this.changeListeners.get(i)).onInventoryChanged(this);
+            }
+        }
+    }
+
+    /**
+     * Do not make give this method the name canInteractWith because it clashes with Container
+     */
+    public boolean isUseableByPlayer(EntityNPC player)
+    {
+        return true;
+    }
+
+    public void openInventory(EntityNPC player)
+    {
+    }
+
+    public void closeInventory(EntityNPC player)
+    {
+    }
+
+    /**
+     * Returns true if automation is allowed to insert the given stack (ignoring stack size) into the given slot.
+     */
+    public boolean isItemValidForSlot(int index, ItemStack stack)
+    {
+        return true;
+    }
+
+    public int getField(int id)
+    {
+        return 0;
+    }
+
+    public void setField(int id, int value)
+    {
+    }
+
+    public int getFieldCount()
+    {
+        return 0;
+    }
+
+    public void clear()
+    {
+        for (int i = 0; i < this.inventoryContents.length; ++i)
+        {
+            this.inventoryContents[i] = null;
+        }
+    }
+}