示例#1
0
    protected virtual bool AttemptGiveItem()
    {
        if (items.Count == 0 || getDropOffSize() == 0)
        {
            return(false);
        }

        ItemBase item  = ItemBaseUtil.newInstance(items[0]);
        int      count = getDropOffSize();

        if (ItemBaseUtil.isStack(items[0]))
        {
            // We have a stacked item, make sure to carry only what we need
            ItemBaseUtil.decrementStack(items[0], count);
            if (ItemBaseUtil.getAmount(items[0]) == 0)
            {
                // Stack no longer exists, remove it.
                // Don't need to set the amount on the item since it already had a =< batch size amount
                items.RemoveAt(0);
            }
            else
            {
                // Stack still exists, so we need to set the amount that we removed
                ItemBaseUtil.setAmount(item, count);
            }
        }
        else
        {
            // No stack, no problem!
            items.RemoveAt(0);
        }

        carriedItems.Add(item);
        return(true);
    }
示例#2
0
 protected virtual bool addItem(ItemBase item)
 {
     if (getStoredItemsCount() >= maxItems)
     {
         return(false);
     }
     if (item.mType == ItemType.ItemCubeStack || item.mType == ItemType.ItemStack)
     {
         for (int j = 0; j < items.Count; ++j)
         {
             // Check if we already have this type of stack
             if (item.mnItemID == items[j].mnItemID && ItemBaseUtil.compareBaseDeep(item, items[j]))
             {
                 if (item.mType == ItemType.ItemCubeStack)
                 {
                     ++(items[j] as ItemCubeStack).mnAmount;
                 }
                 else
                 {
                     ++(items[j] as ItemStack).mnAmount;
                 }
                 return(true);
             }
         }
     }
     items.Add(item);
     return(true);
 }
示例#3
0
 protected virtual int getDropOffSize()
 {
     if (items.Count == 0)
     {
         return(0);
     }
     return(Math.Min(batch, ItemBaseUtil.getAmount(items[0])));
 }
示例#4
0
    public void BuildInventoryList()
    {
        List <KeyValuePair <ItemBase, int> > items = new List <KeyValuePair <ItemBase, int> >();

        for (int index = 0; index <= this.MassStorage.mConnectedCrates.Count; index++)
        {
            MassStorageCrate crate;
            ItemBase         item;
            if (index == this.MassStorage.mConnectedCrates.Count)
            {
                crate = this.MassStorage;
            }
            else
            {
                crate = this.MassStorage.mConnectedCrates[index];
            }

            if (crate.mMode == MassStorageCrate.CrateMode.SingleStack)
            {
                item = crate.mItem;
                if (item != null)
                {
                    int loc = items.FindIndex(x => x.Key.Compare(item));
                    if (loc != -1)
                    {
                        items[loc] = new KeyValuePair <ItemBase, int>(items[loc].Key, items[loc].Value + item.GetAmount());
                    }
                    else
                    {
                        items.Add(new KeyValuePair <ItemBase, int>(ItemBaseUtil.NewInstance(item), item.GetAmount()));
                    }
                }
            }
            else
            {
                for (int n = 0; n < crate.STORAGE_CRATE_SIZE; n++)
                {
                    item = crate.mItems[n];
                    if (item != null)
                    {
                        int loc = items.FindIndex(x => x.Key.Compare(item));
                        if (loc != -1)
                        {
                            items[loc] = new KeyValuePair <ItemBase, int>(items[loc].Key, items[loc].Value + item.GetAmount());
                        }
                        else
                        {
                            items.Add(new KeyValuePair <ItemBase, int>(ItemBaseUtil.NewInstance(item), item.GetAmount()));
                        }
                        item = null;
                    }
                }
            }
        }
        this.Inventory = items;
    }
示例#5
0
    // An item that we'll try taking, and a flag whether we should actually take it or not (we could just be checking if we have space)
    public bool AttemptGiveItem(ItemBase item, int amount = 1, bool actuallyTakeItem = true)
    {
        VicisMod.log(getPrefix(), "Attempting to receive " + amount + " item " + item.GetDisplayString() + " with id = " + item.mnItemID + " and type = " + item.mType);
        // Can we even take this item(s)?
        if (getNumItems() + amount > maxItems)
        {
            return(false);
        }
        for (int i = 0; i < items.Count; ++i)
        {
            if (ItemBaseUtil.compareCubeStack(items[i] as ItemCubeStack, item as ItemCubeStack))
            {
                ItemCubeStack a         = items[i] as ItemCubeStack;
                int           amntTaken = Math.Min(amount, a.mnAmount);
                if (a != null && a.mnAmount < maxBinSize)
                {
                    if (actuallyTakeItem)
                    {
                        a.mnAmount += amount;
                    }
                    MarkDirtyDelayed();
                    return(true);
                }
            }
            else if (ItemBaseUtil.compareStack(items[i] as ItemStack, item as ItemStack))
            {
                ItemStack a = items[i] as ItemStack;
                if (a != null && a.mnAmount < maxBinSize)
                {
                    if (actuallyTakeItem)
                    {
                        a.mnAmount += amount;
                    }
                    MarkDirtyDelayed();
                    return(true);
                }
            }
        }

        if (items.Count < maxBins)
        {
            if (actuallyTakeItem)
            {
                items.Add(item);
            }
            MarkDirtyDelayed();
            return(true);
        }

        VicisMod.log(getPrefix(), "Did not accept item " + item.GetDisplayString());
        return(false);
    }
示例#6
0
        // An item that we're going to give, or check that we can give
        public ItemBase AttemptTakeItem(ItemBase item, int amount = 1, bool actuallyGiveItem = true)
        {
            VicisMod.log(getPrefix(), "Attempting to give " + amount + " item " + item.GetDisplayString() + " with id = " + item.mnItemID + " and type = " + item.mType);
            if (getNumItems() == 0)
            {
                return(null);
            }
            bool itemIsStack = item.isStack();

            for (int i = 0; i < items.Count; ++i)
            {
                if (itemIsStack && items[i].isStackAndSame(item))
                {
                    VicisMod.log(getPrefix(), "Found a CubeStack " + items[i].GetDisplayString() + ", which is storing " + items[i].getAmount() + " blocks");
                    int      amntTaken = Math.Min(amount, items[i].getAmount());
                    ItemBase ret       = ItemBaseUtil.newInstance(items[i]);
                    ret.setAmount(amntTaken);
                    if (actuallyGiveItem)
                    {
                        VicisMod.log(getPrefix(), "Taking Away");
                        items[i].decrementStack(amntTaken);
                        if (items[i].getAmount() == 0)
                        {
                            VicisMod.log(getPrefix(), "There are " + items[i].getAmount() + " items for " + items[i].GetDisplayString() + ", removing it from items");
                            items.RemoveAt(i);
                        }
                        MarkDirtyDelayed();
                    }
                    return(ret);
                }
                else if (!item.isStack() && items[i].compareBase(item))
                {
                    ItemBase ret = items[i];
                    VicisMod.log(getPrefix(), "Found a " + ret.GetDisplayString() + ", with id = " + ret.mnItemID + " and type = " + ret.mType);
                    if (actuallyGiveItem)
                    {
                        VicisMod.log(getPrefix(), "Removing from items");
                        items.RemoveAt(i);
                        MarkDirtyDelayed();
                    }
                    return(ret);
                }
            }

            return(null);
        }
示例#7
0
 public int getNumItems()
 {
     return(ItemBaseUtil.getItemCount(items));
 }
示例#8
0
    // An item that we're going to give, or check that we can give
    public ItemBase AttemptTakeItem(ItemBase item, int amount = 1, bool actuallyGiveItem = true)
    {
        VicisMod.log(getPrefix(), "Attempting to give " + amount + " item " + item.GetDisplayString() + " with id = " + item.mnItemID + " and type = " + item.mType);
        if (getNumItems() == 0)
        {
            return(null);
        }
        for (int i = 0; i < items.Count; ++i)
        {
            if (ItemBaseUtil.compareCubeStack(items[i] as ItemCubeStack, item as ItemCubeStack))
            {
                ItemCubeStack a = items[i] as ItemCubeStack;
                VicisMod.log(getPrefix(), "Found a CubeStack " + a.GetDisplayString() + ", which is storing " + a.mnAmount + " blocks");
                if (a != null)
                {
                    int           amntTaken = Math.Min(amount, a.mnAmount);
                    ItemCubeStack ret       = new ItemCubeStack(a.mCubeType, a.mCubeValue, amntTaken);
                    if (actuallyGiveItem)
                    {
                        VicisMod.log(getPrefix(), "Taking away");
                        a.mnAmount -= amntTaken;
                        if (a.mnAmount <= 0)
                        {
                            VicisMod.log(getPrefix(), "There are " + a.mnAmount + " items for " + a.GetDisplayString() + ", removing it from items");
                            items.RemoveAt(i);
                        }
                    }
                    MarkDirtyDelayed();
                    return(ret);
                }
                // a was null, this is bad. Clean up, hide the evidence
                VicisMod.log(getPrefix(), "Removing a null that masquaraded as an ItemCubeStack!");
                items.RemoveAt(i);
                return(null);
            }
            else if (ItemBaseUtil.compareStack(items[i] as ItemStack, item as ItemStack))
            {
                ItemStack a = items[i] as ItemStack;
                VicisMod.log(getPrefix(), "Found a Stack " + a.GetDisplayString() + ", which is storing " + a.mnAmount + " blocks");
                if (a != null)
                {
                    int       amntTaken = Math.Min(amount, a.mnAmount);
                    ItemStack ret       = new ItemStack(a.mnItemID, amntTaken);
                    if (actuallyGiveItem)
                    {
                        VicisMod.log(getPrefix(), "Taking away");
                        a.mnAmount -= amntTaken;
                        if (a.mnAmount <= 0)
                        {
                            VicisMod.log(getPrefix(), "There are " + a.mnAmount + " items for " + a.GetDisplayString() + ", removing it from items");
                            items.RemoveAt(i);
                        }
                    }
                    MarkDirtyDelayed();
                    return(ret);
                }
                // a was null, this is bad. Clean up, hide the evidence
                VicisMod.log(getPrefix(), "Removing a null that masquaraded as an ItemStack!");
                items.RemoveAt(i);
                return(null);
            }
        }

        if (ItemBaseUtil.isStack(item))
        {
            VicisMod.log(getPrefix(), "Could not find a stack or cube stack for " + item.GetDisplayString() + ", returning null");
            return(null);
        }

        // What we're looking for is not a stack, start looking at the individual items.
        for (int i = 0; i < items.Count; ++i)
        {
            if (ItemBaseUtil.compareBase(items[i], item))
            {
                ItemBase ret = items[i];
                VicisMod.log(getPrefix(), "Found a " + ret.GetDisplayString() + ", with id = " + ret.mnItemID + " and type = " + ret.mType);
                if (actuallyGiveItem)
                {
                    VicisMod.log(getPrefix(), "Removing from items");
                    items.RemoveAt(i);
                }
                MarkDirtyDelayed();
                return(ret);
            }
        }
        return(null);
    }
 protected virtual float getReqPower()
 {
     return(ItemBaseUtil.getItemCount(items) / ippps * powerConsumptionFreq);
 }
示例#10
0
 protected virtual int getItemCount(List <ItemBase> items)
 {
     return(ItemBaseUtil.getItemCount(items));
 }
示例#11
0
    protected virtual void dropOffToConveyors()
    {
        bool ignore;
        List <ConveyorEntity> list = VicisMod.checkSurrounding <ConveyorEntity>(this, out ignore);

        VicisMod.log(getPrefix(), "Found " + list.Count + " ConveyorEntities");
        string msg = items.Count + ": ";

        foreach (ItemBase it in items)
        {
            msg += it.GetDisplayString() + ", ";
        }
        VicisMod.log(getPrefix(), "Currently storing " + msg);
        for (int i = 0; i < list.Count && items.Count > 0; ++i)
        {
            ConveyorEntity c = list[i] as ConveyorEntity;
            if (!isConveyorNotFacingMe(c))
            {
                VicisMod.log(getPrefix(), "Conveyor is either not facing somewhere else: " + isConveyorNotFacingMe(c));
                continue;
            }
            if (c.mbReadyToConvey && c.mrLockTimer == 0f)
            {
                VicisMod.log(getPrefix(), "Ready to convey, will be giving " + items[0].GetDisplayString() + ", a " + items[0].mType);
                if (items[0].mType == ItemType.ItemCubeStack)
                {
                    ItemCubeStack a = items[0] as ItemCubeStack;
                    c.AddCube(a.mCubeType, a.mCubeValue, 1);
                    c.mItemForwards = forwards;
                    --a.mnAmount;
                    if (a.mnAmount == 0)
                    {
                        VicisMod.log(getPrefix(), "Removing cube " + a.GetDisplayString() + " from items list");
                        items.RemoveAt(0);
                    }
                }
                else if (items[0].mType == ItemType.ItemStack)
                {
                    ItemStack a = ItemBaseUtil.newInstance(items[0]) as ItemStack;
                    a.mnAmount = 1;
                    ItemBaseUtil.decrementStack(items[0], 1);
                    c.AddItem(a);
                    c.mItemForwards = forwards;
                    if (ItemBaseUtil.getAmount(items[0]) == 0)
                    {
                        VicisMod.log(getPrefix(), "Removing item " + a.GetDisplayString() + " from items list");
                        items.RemoveAt(0);
                    }
                }
                else
                {
                    c.AddItem(items[0]);
                    c.mrCarryTimer       = 1f;
                    c.mrVisualCarryTimer = 1f;
                    c.mItemForwards      = forwards;
                    items.RemoveAt(0);
                }
            }
            else
            {
                VicisMod.log(getPrefix(), "Conveyor is not ready to convey");
            }
        }
    }