Esempio n. 1
0
        public void LimitCapacityInFullItemStorageSlot()
        {
            var storageSlot = new ItemStorageSlot
                              (
                new IInventoryConstraint[]
            {
                new WeightedInventoryConstraint(3)
            }
                              );

            var template = new ProceduralItemTemplate()
            {
                Weight = 1
            };

            var itemToAddA = new StackableItem(template, 3);
            var itemToAddB = new StackableItem(template, 5);

            storageSlot.AddItem(itemToAddA);
            var result = storageSlot.AddItem(itemToAddB);

            Assert.AreEqual(0, result.Quantity);
            Assert.AreEqual(InventoryResult.OperationStatus.None, result.Status);
            Assert.AreEqual(null, result.ItemAdded);
        }
        public void LimitedSlotCapacityForMultipleStackableItems()
        {
            var storageSlot = new ItemStorageSlot()
            {
                MaxStackSize = 10
            };

            var template = new ProceduralItemTemplate();

            var itemToAddA = new StackableItem(template, 5);
            var itemToAddB = new StackableItem(template, 10);

            storageSlot.AddItem(itemToAddA);
            var result = storageSlot.AddItem(itemToAddB);

            Assert.That(result.Status, Is.EqualTo(TransactionStatus.Partial));
            Assert.That(result.Items, Has.Count.EqualTo(1));
            Assert.That(result.Items[0], Is.EqualTo(new ItemTransaction()
            {
                Quantity      = 5,
                Item          = itemToAddA,
                FromInventory = null,
                ToInventory   = storageSlot
            }));

            Assert.That(itemToAddB.Quantity, Is.EqualTo(5));
            Assert.That(((StackableItem)result.Items[0].Item).Quantity, Is.EqualTo(10));
        }
        public void LimitCapacityInPartiallyFilledItemStorageSlot()
        {
            var storageSlot = new ItemStorageSlot
                              (
                new IInventoryConstraint[]
            {
                new WeightedInventoryConstraint(3)
            }
                              );

            var template = new ProceduralItemTemplate()
            {
                Weight = 1
            };

            var itemToAddA = new StackableItem(template, 2);
            var itemToAddB = new StackableItem(template, 2);

            storageSlot.AddItem(itemToAddA);
            var result = storageSlot.AddItem(itemToAddB);

            var firstTransaction = result.Items[0];

            Assert.AreEqual(3, ((StackableItem)firstTransaction.Item).Quantity);
        }
Esempio n. 4
0
        public void AllowWeightlessItems()
        {
            var storageSlot = new ItemStorageSlot
                              (
                constraints: new IInventoryConstraint[]
            {
                new WeightedInventoryConstraint(10)
            }
                              );

            var template = new ProceduralItemTemplate()
            {
                Weight = 0
            };

            var itemToAddA = new StackableItem(template, 250)
            {
                MaxStackSize = 1000
            };

            var result = storageSlot.AddItem(itemToAddA);

            var firstTransaction = result.Items[0];

            Assert.AreEqual(250, ((StackableItem)firstTransaction.Item).Quantity);
        }
Esempio n. 5
0
        public void DragStackableToStackable()
        {
            var template = new ProceduralItemTemplate();

            var fromItem = new StackableItem(template, 5);
            var toItem   = new StackableItem(template, 10);

            var fromSlot = new ItemStorageSlot();
            var toSlot   = new ItemStorageSlot();

            fromSlot.AddItem(fromItem);
            toSlot.AddItem(toItem);

            var result = fromSlot.DragInto(toSlot);

            var expected = new InventoryTransactionBuilder()
            {
                new ItemTransaction()
                {
                    FromInventory = fromSlot,
                    ToInventory   = toSlot,
                    Item          = fromItem,
                    Quantity      = 15
                }
            }.Build(TransactionStatus.Complete);

            // Assert.That (result, Is.EqualTo (expected));
            Assert.That(fromItem.Quantity, Is.EqualTo(0));
            Assert.That(toItem.Quantity, Is.EqualTo(15));
        }
        public void CompleteOnFilledFromPartial()
        {
            var storageSlot = new ItemStorageSlot()
            {
                MaxStackSize = 10
            };

            var template = new ProceduralItemTemplate();

            var itemToAddA = new StackableItem(template, 5);
            var itemToAddB = new StackableItem(template, 5);

            storageSlot.AddItem(itemToAddA);
            var result = storageSlot.AddItem(itemToAddB);

            Assert.That(result.Status, Is.EqualTo(TransactionStatus.Complete));
            Assert.That(result.Items, Has.Count.EqualTo(1));
            Assert.That(result.Items[0], Is.EqualTo(new ItemTransaction()
            {
                Quantity      = 5,
                Item          = itemToAddA,
                FromInventory = null,
                ToInventory   = storageSlot
            }));
        }
Esempio n. 7
0
        public void CompleteOnFilledFromEmpty()
        {
            var storageSlot = new ItemStorageSlot()
            {
                MaxStackSize = 10
            };

            var template = new ProceduralItemTemplate();

            var itemToAddA = new StackableItem(template, 10);

            var result = storageSlot.AddItem(itemToAddA);

            Assert.AreEqual(10, result.Quantity);
            Assert.AreEqual(InventoryResult.OperationStatus.Complete, result.Status);
            Assert.AreEqual(itemToAddA, result.ItemAdded);
        }
        public void NoneOnTryAddToFullStackableSlot()
        {
            var storageSlot = new ItemStorageSlot()
            {
                MaxStackSize = 10
            };

            var template = new ProceduralItemTemplate();

            var itemToAddA = new StackableItem(template, 10);
            var itemToAddB = new StackableItem(template, 15);

            storageSlot.AddItem(itemToAddA);
            var result = storageSlot.AddItem(itemToAddB);

            Assert.AreEqual(TransactionStatus.None, result.Status);
        }
        public void NoneOnTryAddToFullStackableSlot()
        {
            var storageSlot = new ItemStorageSlot()
            {
                MaxStackSize = 10
            };

            var template = new ProceduralItemTemplate();

            var itemToAddA = new StackableItem(template, 10);
            var itemToAddB = new StackableItem(template, 15);

            storageSlot.AddItem(itemToAddA);
            var result = storageSlot.AddItem(itemToAddB);

            Assert.That(result, Is.EqualTo(InventoryTransaction.None));
        }
Esempio n. 10
0
        public void MoveStackableToStackableSlot()
        {
            var template = new ProceduralItemTemplate();

            var fromItem = new StackableItem(template, 5);
            var toItem   = new StackableItem(template, 10);

            var fromSlot = new ItemStorageSlot();
            var toSlot   = new ItemStorageSlot();

            fromSlot.AddItem(fromItem);
            toSlot.AddItem(toItem);

            fromSlot.MoveInto(toSlot);

            Assert.AreEqual(null, fromSlot.CurrentItem);
            Assert.AreEqual(toItem, toSlot.CurrentItem);
        }
        public void DragStackableToStackable()
        {
            var template = new ProceduralItemTemplate();

            var fromItem = new StackableItem(template, 5);
            var toItem   = new StackableItem(template, 10);

            var fromSlot = new ItemStorageSlot();
            var toSlot   = new ItemStorageSlot();

            fromSlot.AddItem(fromItem);
            toSlot.AddItem(toItem);

            fromSlot.DragInto(toSlot);

            Assert.AreEqual(0, fromItem.Quantity);
            Assert.AreEqual(15, toItem.Quantity);
        }
Esempio n. 12
0
        public void SwapUniqueToUnique()
        {
            var template = new ProceduralItemTemplate();

            var fromItem = new UniqueItem(template);
            var toItem   = new UniqueItem(template);

            var fromSlot = new ItemStorageSlot();
            var toSlot   = new ItemStorageSlot();

            fromSlot.AddItem(fromItem);
            toSlot.AddItem(toItem);

            fromSlot.Swap(toSlot);

            Assert.AreEqual(toItem, fromSlot.CurrentItem);
            Assert.AreEqual(fromItem, toSlot.CurrentItem);
        }
Esempio n. 13
0
        public void LimitedSlotCapacityForMultipleStackableItems()
        {
            var storageSlot = new ItemStorageSlot()
            {
                MaxStackSize = 10
            };

            var template = new ProceduralItemTemplate();

            var itemToAddA = new StackableItem(template, 5);
            var itemToAddB = new StackableItem(template, 10);

            storageSlot.AddItem(itemToAddA);
            var result = storageSlot.AddItem(itemToAddB);

            Assert.AreEqual(5, itemToAddB.Quantity);
            Assert.AreEqual(10, ((StackableItem)result.ItemAdded).Quantity);
        }
Esempio n. 14
0
        public void NoneOnTryAddToFullStackableSlot()
        {
            var storageSlot = new ItemStorageSlot()
            {
                MaxStackSize = 10
            };

            var template = new ProceduralItemTemplate();

            var itemToAddA = new StackableItem(template, 10);
            var itemToAddB = new StackableItem(template, 15);

            storageSlot.AddItem(itemToAddA);
            var result = storageSlot.AddItem(itemToAddB);

            Assert.AreEqual(0, result.Quantity);
            Assert.AreEqual(InventoryResult.OperationStatus.None, result.Status);
            Assert.AreEqual(null, result.ItemAdded);
        }
        public void DeclineOverweightedItems()
        {
            var storageSlot = new ItemStorageSlot
                              (
                new IInventoryConstraint[]
            {
                new WeightedInventoryConstraint(10)
            }
                              );

            var template = new ProceduralItemTemplate()
            {
                Weight = 100
            };

            var itemToAdd = new StackableItem(template, 1);
            var result    = storageSlot.AddItem(itemToAdd);

            Assert.AreEqual(TransactionStatus.None, result.Status);
        }
Esempio n. 16
0
        public void AllowWeightlessItems()
        {
            var storageSlot = new ItemStorageSlot
                              (
                new IInventoryConstraint[]
            {
                new WeightedInventoryConstraint(10)
            }
                              );

            var template = new ProceduralItemTemplate()
            {
                Weight = 0
            };

            var itemToAddA = new StackableItem(template, 250);
            var result     = storageSlot.AddItem(itemToAddA);

            Assert.AreEqual(250, ((StackableItem)result.ItemAdded).Quantity);
        }
        public void CompleteOnFilledFromEmpty()
        {
            var storageSlot = new ItemStorageSlot()
            {
                MaxStackSize = 10
            };

            var template = new ProceduralItemTemplate();

            var itemToAddA = new StackableItem(template, 10);

            var result = storageSlot.AddItem(itemToAddA);

            var firstTransaction = result.Items[0];

            Assert.AreEqual(TransactionStatus.Complete, result.Status);
            Assert.AreEqual(10, firstTransaction.Quantity);
            Assert.AreEqual(itemToAddA, firstTransaction.Item);
            Assert.AreEqual(null, firstTransaction.FromInventory);
            Assert.AreEqual(storageSlot, firstTransaction.ToInventory);
        }
Esempio n. 18
0
        public void LimitCapacityInEmptyFilledItemStorageSlot()
        {
            var storageSlot = new ItemStorageSlot
                              (
                new IInventoryConstraint[]
            {
                new WeightedInventoryConstraint(5)
            }
                              );

            var template = new ProceduralItemTemplate()
            {
                Weight = 1
            };

            var itemToAddA = new StackableItem(template, 10);

            var result = storageSlot.AddItem(itemToAddA);

            Assert.AreEqual(5, ((StackableItem)result.ItemAdded).Quantity);
        }
Esempio n. 19
0
        public void SwapStackableToPartial()
        {
            var template = new ProceduralItemTemplate();

            var fromItem = new StackableItem(template, 5);
            var toItem   = new StackableItem(template, 10);

            var fromSlot = new ItemStorageSlot();
            var toSlot   = new ItemStorageSlot()
            {
                MaxStackSize = 15
            };

            fromSlot.AddItem(fromItem);
            toSlot.AddItem(toItem);

            fromSlot.Swap(toSlot);

            Assert.AreEqual(toItem, fromSlot.CurrentItem);
            Assert.AreEqual(fromItem, toSlot.CurrentItem);
        }
        public void LimitedSlotCapacityForMultipleStackableItems()
        {
            var storageSlot = new ItemStorageSlot()
            {
                MaxStackSize = 10
            };

            var template = new ProceduralItemTemplate();

            var itemToAddA = new StackableItem(template, 5);
            var itemToAddB = new StackableItem(template, 10);

            storageSlot.AddItem(itemToAddA);
            var result = storageSlot.AddItem(itemToAddB);

            var firstTransaction = result.Items[0];

            Assert.AreEqual(5, itemToAddB.Quantity);
            Assert.AreEqual(10, ((StackableItem)firstTransaction.Item).Quantity);
            Assert.AreEqual(null, firstTransaction.FromInventory);
            Assert.AreEqual(storageSlot, firstTransaction.ToInventory);
        }
Esempio n. 21
0
        public void MoveStackableToStackableSlotOverflow()
        {
            var template = new ProceduralItemTemplate();

            var fromItem = new StackableItem(template, 10);
            var toItem   = new StackableItem(template, 5);

            var fromSlot = new ItemStorageSlot();
            var toSlot   = new ItemStorageSlot()
            {
                MaxStackSize = 10
            };

            fromSlot.AddItem(fromItem);
            toSlot.AddItem(toItem);

            var result = fromSlot.MoveInto(toSlot);

            Assert.AreEqual(TransactionStatus.Partial, result.Status);
            Assert.AreEqual(fromItem, fromSlot.CurrentItem);
            Assert.AreEqual(toItem, toSlot.CurrentItem);
        }