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 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 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 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 MoveEmptyToEmptySlot()
{
var fromSlot = new ItemStorageSlot();
var toSlot = new ItemStorageSlot();
fromSlot.MoveInto(toSlot);
Assert.AreEqual(null, fromSlot.CurrentItem);
Assert.AreEqual(null, toSlot.CurrentItem);
}
public void EmptySelectToEmptyStorage()
{
var fromSlot = new ItemSelectSlot();
var toSlot = new ItemStorageSlot();
fromSlot.SwapInto(toSlot);
Assert.AreEqual(null, fromSlot.CurrentItem);
Assert.AreEqual(null, toSlot.CurrentItem);
}
public void SwapEmptyToEmpty()
{
var fromSlot = new ItemStorageSlot();
var toSlot = new ItemStorageSlot();
fromSlot.Swap(toSlot);
Assert.AreEqual(null, fromSlot.CurrentItem);
Assert.AreEqual(null, toSlot.CurrentItem);
}
public void DragEmptyToEmpty()
{
var fromSlot = new ItemStorageSlot();
var toSlot = new ItemStorageSlot();
var result = fromSlot.DragInto(toSlot);
Assert.That(result, Is.EqualTo(InventoryTransaction.None));
Assert.That(fromSlot.CurrentItem, Is.Null);
Assert.That(toSlot.CurrentItem, Is.Null);
}
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.That(result, Is.EqualTo(InventoryTransaction.None));
}
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 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 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 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 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 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 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 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 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);
}
