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 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);
}
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 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
}));
}
public void NoneOnTryAddUniqueItemAddedToOccupiedSlot()
{
var storageSlot = new ItemStorageSlot();
var oldItem = new StackableItem(new ProceduralItemTemplate(), 15);
var newItem = new UniqueItem(new ProceduralItemTemplate());
storageSlot.AddItem(oldItem);
var result = storageSlot.AddItem(newItem);
Assert.That(result, Is.EqualTo(InventoryTransaction.None));
}
public void NoneOnTryAddUniqueItemAddedToOccupiedSlot()
{
var storageSlot = new ItemStorageSlot();
var oldItem = new StackableItem(new ProceduralItemTemplate(), 15);
var newItem = new UniqueItem(new ProceduralItemTemplate());
storageSlot.AddItem(oldItem);
var result = storageSlot.AddItem(newItem);
Assert.AreEqual(TransactionStatus.None, result.Status);
}
public void NoneOnTryAddUniqueItemAddedToOccupiedSlot()
{
var storageSlot = new ItemStorageSlot();
var oldItem = new StackableItem(new ProceduralItemTemplate(), 15);
var newItem = new UniqueItem(new ProceduralItemTemplate());
storageSlot.AddItem(oldItem);
var result = storageSlot.AddItem(newItem);
Assert.AreEqual(0, result.Quantity);
Assert.AreEqual(InventoryResult.OperationStatus.None, result.Status);
Assert.AreEqual(null, result.ItemAdded);
}
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 StoreUniqueItem()
{
var storageSlot = new ItemStorageSlot();
var itemToAdd = new UniqueItem(new ProceduralItemTemplate());
var result = storageSlot.AddItem(itemToAdd);
var firstTransaction = result.Items[0];
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 = 1,
Item = itemToAdd,
FromInventory = null,
ToInventory = storageSlot
}));
Assert.AreEqual(TransactionStatus.Complete, result.Status);
Assert.AreEqual(itemToAdd, storageSlot.CurrentItem);
Assert.AreEqual(null, firstTransaction.FromInventory);
Assert.AreEqual(storageSlot, firstTransaction.ToInventory);
}
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);
}
public void LimitedSlotCapacityForSingleStackableItem()
{
var storageSlot = new ItemStorageSlot()
{
MaxStackSize = 10
};
var itemToAdd = new StackableItem(new ProceduralItemTemplate(), 15);
Assert.AreEqual(15, itemToAdd.Quantity);
var result = storageSlot.AddItem(itemToAdd);
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 = 10,
Item = storageSlot.CurrentItem,
FromInventory = null,
ToInventory = storageSlot
}));
Assert.That(itemToAdd.Quantity, Is.EqualTo(5));
Assert.That(((StackableItem)result.Items[0].Item).Quantity, Is.EqualTo(10));
}
public void DragStackableToEmpty()
{
var fromItem = new StackableItem(new ProceduralItemTemplate(), 5);
var fromSlot = new ItemStorageSlot();
var toSlot = new ItemStorageSlot();
fromSlot.AddItem(fromItem);
var result = fromSlot.DragInto(toSlot);
var expected = new InventoryTransactionBuilder()
{
new ItemTransaction()
{
FromInventory = null,
ToInventory = toSlot,
Item = fromItem,
Quantity = 5
}
}.Build(TransactionStatus.Complete);
Assert.That(result, Is.EqualTo(expected));
Assert.That(fromSlot.CurrentItem, Is.Null);
Assert.That(toSlot.CurrentItem, Is.EqualTo(fromItem));
}
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));
}
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);
}
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.AreEqual(5, 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(0, result.Quantity);
Assert.AreEqual(InventoryResult.OperationStatus.None, result.Status);
Assert.AreEqual(null, result.ItemAdded);
}
public void StoreUniqueItem()
{
var storageSlot = new ItemStorageSlot();
var itemToAdd = new UniqueItem(new ProceduralItemTemplate());
storageSlot.AddItem(itemToAdd);
Assert.AreEqual(itemToAdd, storageSlot.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);
}
public void DragEmptyToStackable()
{
var toItem = new StackableItem(new ProceduralItemTemplate(), 5);
var fromSlot = new ItemStorageSlot();
var toSlot = new ItemStorageSlot();
toSlot.AddItem(toItem);
fromSlot.DragInto(toSlot);
Assert.AreEqual(null, fromSlot.CurrentItem);
Assert.AreEqual(toItem, toSlot.CurrentItem);
}
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);
var firstTransaction = result.Items[0];
Assert.AreEqual(TransactionStatus.Complete, result.Status);
Assert.AreEqual(5, firstTransaction.Quantity);
Assert.AreEqual(itemToAddA, firstTransaction.Item);
Assert.AreEqual(null, firstTransaction.FromInventory);
Assert.AreEqual(storageSlot, firstTransaction.ToInventory);
}
public void DragUniqueToEmpty()
{
var fromItem = new UniqueItem(new ProceduralItemTemplate());
var fromSlot = new ItemStorageSlot();
var toSlot = new ItemStorageSlot();
fromSlot.AddItem(fromItem);
fromSlot.DragInto(toSlot);
Assert.AreEqual(null, fromSlot.CurrentItem);
Assert.AreEqual(fromItem, toSlot.CurrentItem);
}
public void MoveEmptyToUniqueSlot()
{
var toItem = new UniqueItem(new ProceduralItemTemplate());
var fromSlot = new ItemStorageSlot();
var toSlot = new ItemStorageSlot();
toSlot.AddItem(toItem);
fromSlot.MoveInto(toSlot);
Assert.AreEqual(null, fromSlot.CurrentItem);
Assert.AreEqual(toItem, toSlot.CurrentItem);
}
public void MoveStackableToEmptySlot()
{
var fromItem = new StackableItem(new ProceduralItemTemplate(), 5);
var fromSlot = new ItemStorageSlot();
var toSlot = new ItemStorageSlot();
fromSlot.AddItem(fromItem);
fromSlot.MoveInto(toSlot);
Assert.AreEqual(null, fromSlot.CurrentItem);
Assert.AreEqual(fromItem, toSlot.CurrentItem);
}
public void EmptySelectToFullStorage()
{
var toItem = new StackableItem(new ProceduralItemTemplate(), 5);
var fromSlot = new ItemSelectSlot();
var toSlot = new ItemStorageSlot();
toSlot.AddItem(toItem);
fromSlot.SwapInto(toSlot);
Assert.AreEqual(toItem, fromSlot.CurrentItem);
Assert.AreEqual(toItem, toSlot.CurrentItem);
}
public void DragEmptyToUnique()
{
var toItem = new UniqueItem(new ProceduralItemTemplate());
var fromSlot = new ItemStorageSlot();
var toSlot = new ItemStorageSlot();
toSlot.AddItem(toItem);
var result = fromSlot.DragInto(toSlot);
Assert.That(result, Is.EqualTo(InventoryTransaction.None));
Assert.That(fromSlot.CurrentItem, Is.Null);
Assert.That(toSlot.CurrentItem, Is.EqualTo(toItem));
}
public void StoreUniqueItem()
{
var storageSlot = new ItemStorageSlot();
var itemToAdd = new UniqueItem(new ProceduralItemTemplate());
var result = storageSlot.AddItem(itemToAdd);
var firstTransaction = result.Items[0];
Assert.AreEqual(TransactionStatus.Complete, result.Status);
Assert.AreEqual(itemToAdd, storageSlot.CurrentItem);
Assert.AreEqual(null, firstTransaction.FromInventory);
Assert.AreEqual(storageSlot, firstTransaction.ToInventory);
}
public void DragStackableToStackableOfDifferentType()
{
var fromItem = new StackableItem(new ProceduralItemTemplate(), 5);
var toItem = new StackableItem(new ProceduralItemTemplate(), 5);
var fromSlot = new ItemStorageSlot();
var toSlot = new ItemStorageSlot();
fromSlot.AddItem(fromItem);
toSlot.AddItem(toItem);
fromSlot.DragInto(toSlot);
Assert.AreEqual(toItem, fromSlot.CurrentItem);
Assert.AreEqual(fromItem, toSlot.CurrentItem);
}
public void LimitedSlotCapacityForStackableItems()
{
var storageSlot = new ItemStorageSlot()
{
MaxStackSize = 10
};
var itemToAdd = new StackableItem(new ProceduralItemTemplate(), 15);
Assert.AreEqual(15, itemToAdd.Quantity);
var result = storageSlot.AddItem(itemToAdd);
Assert.AreEqual(10, result.Quantity);
Assert.AreEqual(10, ((StackableItem)result.ItemAdded).Quantity);
Assert.AreEqual(5, itemToAdd.Quantity);
}
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);
}